kuzzle 2.49.1 → 2.50.0-beta.4

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

@@ -0,0 +1,46 @@
+export = RouteHandler;
+/**
+ * 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;
+    connection: {
+        connection: {
+            headers: any;
+            id: any;
+            ips: any;
+            path: any;
+            protocol: string;
+            url: any;
+            verb: any;
+        };
+    };
+    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
+     */
+    invokeHandler(callback: Function): void;
+}
+import { Request } from "../../../api/request/kuzzleRequest";

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

@@ -0,0 +1,101 @@
+/*
+ * 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 { Request } = require("../../../api/request");
+const kerror = require("../../../kerror").wrap("network", "http");
+/**
+ * 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
+ */
+class RouteHandler {
+    constructor(url, query, message) {
+        this.handler = null;
+        this._request = null;
+        this.url = url;
+        this.data = {
+            body: message.content,
+            requestId: message.requestId,
+            ...query,
+        };
+        this.connection = {
+            connection: {
+                headers: message.headers,
+                id: message.connection.id,
+                ips: message.ips,
+                path: message.path,
+                protocol: "http",
+                // @deprecated use "path" instead
+                url: message.url,
+                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);
+            }
+            else if (k.toLowerCase() === "x-kuzzle-volatile") {
+                try {
+                    this.data.volatile = JSON.parse(message.headers[k]);
+                }
+                catch (e) {
+                    throw kerror.getFrom(e, "volatile_parse_failed", e.message);
+                }
+            }
+        }
+    }
+    get request() {
+        if (this._request === null) {
+            this._request = new Request(this.data, this.connection);
+        }
+        return this._request;
+    }
+    /**
+     * Add a parametric argument to the request object
+     * @param {string} name
+     * @param {string} value
+     */
+    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

@@ -0,0 +1,35 @@
+export = RoutePart;
+/**
+ * Defines a new route part
+ *
+ * @class RoutePart
+ */
+declare class RoutePart {
+    subparts: {};
+    placeholders: any;
+    handler: any;
+    /**
+     * 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}
+     */
+    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");

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

@@ -0,0 +1,117 @@
+/*
+ * 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 URL = require("url");
+const querystring = require("querystring");
+const RouteHandler = require("./routeHandler");
+const { has } = require("../../../util/safeObject");
+/**
+ * Defines a new route part
+ *
+ * @class RoutePart
+ */
+class RoutePart {
+    constructor() {
+        this.subparts = {};
+        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);
+    }
+    /**
+     * Gets the next element of an URL part, creating a new
+     * tree leaf if necessary
+     *
+     * @param {string} part
+     * @returns {RoutePart}
+     */
+    getNext(part) {
+        if (!has(this.subparts, part)) {
+            this.subparts[part] = new RoutePart();
+        }
+        return this.subparts[part];
+    }
+    /**
+     * 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);
+        let pathname = parsed.pathname || ""; // pathname is set to null if empty
+        if (pathname[pathname.length - 1] === "/") {
+            pathname = pathname.slice(0, -1);
+        }
+        const routeHandler = new RouteHandler(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
+ */
+function getHandlerPart(routePart, parts, routeHandler, placeholders = []) {
+    let part;
+    do {
+        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]);
+            }
+        }
+        return routeHandler;
+    }
+    part = querystring.unescape(part);
+    if (has(routePart.subparts, part)) {
+        return getHandlerPart(routePart.subparts[part], parts, routeHandler, placeholders);
+    }
+    if (routePart.subparts["*"]) {
+        placeholders.push(part);
+        return getHandlerPart(routePart.subparts["*"], parts, routeHandler, placeholders);
+    }
+    return routeHandler;
+}
+/**
+ * @type {RoutePart}
+ */
+module.exports = RoutePart;
+//# sourceMappingURL=routePart.js.map

package/dist/lib/core/network/protocolManifest.d.ts

@@ -0,0 +1,6 @@
+export = ProtocolManifest;
+declare class ProtocolManifest extends AbstractManifest {
+    constructor(protocolPath: any, protocol: any);
+    protocol: any;
+}
+import AbstractManifest = require("../shared/abstractManifest");

package/{lib → dist/lib}/core/network/protocolManifest.js

@@ -18,17 +18,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 "use strict";
-
 const AbstractManifest = require("../shared/abstractManifest");
-
 class ProtocolManifest extends AbstractManifest {
-  constructor(protocolPath, protocol) {
-    super(protocolPath);
-
-    this.protocol = protocol;
-  }
+    constructor(protocolPath, protocol) {
+        super(protocolPath);
+        this.protocol = protocol;
+    }
 }
-
 module.exports = ProtocolManifest;
+//# sourceMappingURL=protocolManifest.js.map

package/dist/lib/core/network/protocols/httpMessage.d.ts

@@ -0,0 +1,22 @@
+export = HttpMessage;
+/**
+ * @class HttpMessage
+ */
+declare class HttpMessage {
+    /**
+     * @param {ClientConnection} connection
+     * @param {uWS.HttpRequest} request
+     */
+    constructor(connection: ClientConnection, request: uWS.HttpRequest);
+    connection: ClientConnection;
+    _content: any;
+    ips: any;
+    query: any;
+    path: any;
+    url: any;
+    method: any;
+    headers: {};
+    requestId: any;
+    set content(value: any);
+    get content(): any;
+}

package/dist/lib/core/network/protocols/httpMessage.js

@@ -0,0 +1,62 @@
+/*
+ * 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";
+/**
+ * @class HttpMessage
+ */
+class HttpMessage {
+    /**
+     * @param {ClientConnection} connection
+     * @param {uWS.HttpRequest} request
+     */
+    constructor(connection, request) {
+        this.connection = connection;
+        this._content = null;
+        this.ips = connection.ips;
+        this.query = request.getQuery();
+        this.path = request.getUrl();
+        if (this.query && this.query.length > 0) {
+            this.path = `${request.getUrl()}?${this.query}`;
+        }
+        else {
+            this.path = request.getUrl();
+        }
+        // @deprecated use "path" instead
+        this.url = this.path;
+        this.method = request.getMethod().toUpperCase();
+        this.headers = {};
+        request.forEach((name, value) => (this.headers[name] = value));
+        this.requestId = this.headers["x-kuzzle-request-id"] || connection.id;
+    }
+    set content(value) {
+        if (!value || value.length === 0) {
+            this._content = null;
+        }
+        else {
+            this._content = value;
+        }
+    }
+    get content() {
+        return this._content;
+    }
+}
+module.exports = HttpMessage;
+//# sourceMappingURL=httpMessage.js.map

package/dist/lib/core/network/protocols/httpwsProtocol.d.ts

@@ -0,0 +1,171 @@
+export = HttpWsProtocol;
+/**
+ * @class HTTPWS
+ * Handles both HTTP and WebSocket connections
+ */
+declare class HttpWsProtocol extends Protocol {
+    constructor();
+    server: uWS.TemplatedApp;
+    wsConfig: {
+        enabled: boolean;
+        opts?: undefined;
+        rateLimit?: undefined;
+    } | {
+        enabled: any;
+        opts: {
+            compression: number;
+            idleTimeout: number;
+            maxPayloadLength: number;
+            resetIdleTimeoutOnSend: any;
+            sendPingsAutomatically: any;
+        };
+        rateLimit: any;
+    };
+    httpConfig: {
+        enabled: boolean;
+        headers?: undefined;
+        opts?: undefined;
+    } | {
+        enabled: any;
+        headers: string[][];
+        opts: {
+            allowCompression: any;
+            allowedContentTypes: any[];
+            maxEncodingLayers: any;
+            maxFormFileSize: any;
+        };
+    };
+    now: number;
+    nowInterval: NodeJS.Timeout;
+    connectionBySocket: Map<any, any>;
+    backpressureBuffer: Map<any, any>;
+    socketByConnectionId: Map<any, any>;
+    logger: import("../../../kuzzle/Logger").Logger;
+    init(entrypoint: any): Promise<boolean>;
+    initWebSocket(): void;
+    initHttp(): void;
+    broadcast(data: any): void;
+    notify(data: any): void;
+    joinChannel(channel: any, connectionId: any): void;
+    leaveChannel(channel: any, connectionId: any): void;
+    disconnect(connectionId: any, message?: any): void;
+    wsOnUpgradeHandler(res: any, req: any, context: any): void;
+    wsOnOpenHandler(socket: any): void;
+    wsOnCloseHandler(socket: any, code: any, message: any): void;
+    wsOnMessageHandler(socket: any, data: any): Promise<void>;
+    /**
+     * Absorb as much of the backpressure buffer as possible
+     * @param  {uWS.WebSocket} socket
+     */
+    wsOnDrainHandler(socket: uWS.WebSocket<any>): void;
+    /**
+     * Forwards an error to a socket
+     *
+     * @param  {uWS.WebSocket} socket
+     * @param  {ClientConnection} connection
+     * @param  {Error} error
+     * @param  {String} requestId @optional
+     */
+    wsSendError(socket: uWS.WebSocket<any>, connection: ClientConnection, error: Error, requestId: string): void;
+    /**
+     * Sends a message immediately, or queue it up for later if backpressure built
+     * up
+     *
+     * @param  {uWS.WebSocket} socket
+     * @param  {Buffer} payload
+     */
+    wsSend(socket: uWS.WebSocket<any>, payload: Buffer): void;
+    /**
+     * @param  {uWS.HttpResponse} response
+     * @param  {uWS.HttpRequest} request
+     */
+    httpOnMessageHandler(response: uWS.HttpResponse, request: uWS.HttpRequest): void;
+    /**
+     * Read an HTTP payload data
+     *
+     * @param  {HttpMessage} message
+     * @param  {uWS.HttpResponse} response
+     * @param  {Function} cb
+     */
+    httpReadData(message: HttpMessage, response: uWS.HttpResponse, cb: Function): void;
+    httpParseContent(message: any, content: any, cb: any): Promise<void>;
+    httpProcessRequest(response: any, message: any): void;
+    /**
+     *
+     * @param {uWS.HttpRequest} request
+     * @param {uWS.HttpResponse} response
+     * @param {HttpMessage} message
+     */
+    httpWriteRequestHeaders(request: uWS.HttpRequest, response: uWS.HttpResponse, message: HttpMessage): void;
+    /**
+     * Send stream data thorugh the HTTP response
+     * @param {HttpRequest} request
+     * @param {HttpStream} httpStream - The data stream to send
+     * @param {uWS.HttpResponse} response
+     * @param {HttpMessage} message
+     */
+    httpSendStream(request: HttpRequest, response: uWS.HttpResponse, httpStream: HttpStream, message: HttpMessage): void;
+    /**
+     * Forward an error response to the client
+     *
+     * @param {HttpMessage} message
+     * @param {uWS.HttpResponse} response
+     * @param {Error} error
+     */
+    httpSendError(message: HttpMessage, response: uWS.HttpResponse, error: Error): void;
+    /**
+     * Convert a Kuzzle query result into an appropriate payload format
+     * to send back to the client
+     *
+     * @param {Request} request
+     * @param {HttpMessage} message
+     * @returns {Buffer}
+     */
+    httpRequestToResponse(request: Request, message: HttpMessage): Buffer;
+    /**
+     * Compress an outgoing message according to the
+     * specified accept-encoding HTTP header
+     *
+     * @param  {HttpMessage} message
+     * @param  {Buffer} data
+     * @param  {Function} callback
+     */
+    httpCompress(message: HttpMessage, data: Buffer, callback: Function): void;
+    httpUncompress(message: any, payload: any, cb: any): void;
+    httpUncompressStep(encodings: any, payload: any, cb: any, index: any): void;
+    parseWebSocketOptions(): {
+        enabled: boolean;
+        opts?: undefined;
+        rateLimit?: undefined;
+    } | {
+        enabled: any;
+        opts: {
+            compression: number;
+            idleTimeout: number;
+            maxPayloadLength: number;
+            resetIdleTimeoutOnSend: any;
+            sendPingsAutomatically: any;
+        };
+        rateLimit: any;
+    };
+    parseHttpOptions(): {
+        enabled: boolean;
+        headers?: undefined;
+        opts?: undefined;
+    } | {
+        enabled: any;
+        headers: string[][];
+        opts: {
+            allowCompression: any;
+            allowedContentTypes: any[];
+            maxEncodingLayers: any;
+            maxFormFileSize: any;
+        };
+    };
+}
+import Protocol = require("./protocol");
+import uWS = require("uWebSockets.js");
+import ClientConnection = require("../clientConnection");
+import HttpMessage = require("./httpMessage");
+import { HttpStream } from "../../../types/HttpStream";
+import { Request } from "../../../api/request/kuzzleRequest";