kuzzle 2.56.0 → 2.57.0-beta.2

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

@@ -0,0 +1,23 @@
+"use strict";
+/*
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=routeTypes.js.map

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

@@ -0,0 +1,20 @@
+import type { JSONObject } from "../../types/JSONObject";
+import type { KuzzleRequest } from "../../api/request";
+import type { ServerConfiguration } from "../../types";
+import type ClientConnection from "./clientConnection";
+/**
+ * The EntryPoint surface a protocol is allowed to reach.
+ *
+ * `entryPoint.js` is still JavaScript (it is converted by sprint 6's PR H6).
+ * Declaring the contract here rather than inferring it from that file is not
+ * only a stop-gap: the inference is actively wrong, because the JSDoc
+ * `@param {Request}` resolves to the **DOM** `Request` — `lib.dom` is in
+ * `tsconfig.json`'s `lib` and nothing imports Kuzzle's `Request` into scope.
+ */
+export interface NetworkEntryPoint {
+    config: ServerConfiguration;
+    execute(connection: ClientConnection, request: KuzzleRequest, cb: (response: JSONObject) => void): void;
+    logAccess(connection: ClientConnection, request: KuzzleRequest, extra?: JSONObject | null): void;
+    newConnection(connection: ClientConnection): void;
+    removeConnection(connectionId: string): void;
+}

package/dist/lib/core/network/networkEntryPoint.js

@@ -0,0 +1,23 @@
+"use strict";
+/*
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=networkEntryPoint.js.map

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

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

package/dist/lib/core/network/protocolManifest.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,9 +19,11 @@
  * 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 {
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const abstractManifest_1 = __importDefault(require("../shared/abstractManifest"));
+class ProtocolManifest extends abstractManifest_1.default {
     constructor(protocolPath, protocol) {
         super(protocolPath);
         this.protocol = protocol;

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

@@ -1,22 +1,29 @@
-export = HttpMessage;
-/**
- * @class HttpMessage
- */
+/// <reference types="node" />
+/// <reference types="node" />
+import type { JSONObject } from "../../../types/JSONObject";
+import type * as uWS from "uWebSockets.js";
+import type ClientConnection from "../clientConnection";
+/** What a request body can be once parsed, or `null` when there is none. */
+type HttpMessageContent = Buffer | JSONObject | null;
 declare class HttpMessage {
+    connection: ClientConnection;
+    ips: string[];
+    query: string;
+    path: string;
+    /** @deprecated use "path" instead */
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    requestId: string;
+    private _content;
     /**
-     * @param {ClientConnection} connection
-     * @param {uWS.HttpRequest} request
+     * @param headers - the request's headers when the caller has already
+     * collected them (a uWS `HttpRequest` only exposes them through `forEach`, so
+     * `httpwsProtocol` collects them once for both the connection and the
+     * message); omitted, they are collected here.
      */
-    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;
+    constructor(connection: ClientConnection, request: uWS.HttpRequest, headers?: Record<string, string>);
+    set content(value: HttpMessageContent);
+    get content(): HttpMessageContent;
 }
+export = HttpMessage;

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

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,16 +19,14 @@
  * 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
+     * @param headers - the request's headers when the caller has already
+     * collected them (a uWS `HttpRequest` only exposes them through `forEach`, so
+     * `httpwsProtocol` collects them once for both the connection and the
+     * message); omitted, they are collected here.
      */
-    constructor(connection, request) {
+    constructor(connection, request, headers) {
         this.connection = connection;
         this._content = null;
         this.ips = connection.ips;
@@ -39,11 +38,15 @@ class HttpMessage {
         else {
             this.path = request.getUrl();
         }
-        // @deprecated use "path" instead
-        this.url = this.path;
+        this.url = this.path; // NOSONAR this is what declares the alias
         this.method = request.getMethod().toUpperCase();
-        this.headers = {};
-        request.forEach((name, value) => (this.headers[name] = value));
+        if (headers) {
+            this.headers = headers;
+        }
+        else {
+            this.headers = {};
+            request.forEach((name, value) => (this.headers[name] = value));
+        }
         this.requestId = this.headers["x-kuzzle-request-id"] || connection.id;
     }
     set content(value) {

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

@@ -1,63 +1,72 @@
-export = HttpWsProtocol;
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import type { JSONObject } from "../../../types/JSONObject";
+import uWS from "uWebSockets.js";
+import { Request } from "../../../api/request";
+import { KuzzleError } from "../../../kerror/errors";
+import { HttpStream } from "../../../types";
+import ClientConnection from "../clientConnection";
+import type { KuzzleWebSocket } from "../../../types/KuzzleWebSocket";
+import HttpMessage from "./httpMessage";
+import type { NetworkEntryPoint } from "../networkEntryPoint";
+import Protocol from "./protocol";
 /**
  * @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;
-        };
-    };
+/**
+ * `server.protocols` as this protocol reads it: the `websocket` and `http`
+ * blocks of the Kuzzle configuration.
+ */
+interface HttpWsProtocolConfig {
+    websocket: JSONObject;
+    http: JSONObject;
+}
+declare class HttpWsProtocol extends Protocol<HttpWsProtocolConfig> {
+    private _server;
+    private _wsConfig;
+    private _httpConfig;
     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>;
+    connectionBySocket: Map<KuzzleWebSocket, ClientConnection>;
+    backpressureBuffer: Map<KuzzleWebSocket, Buffer[]>;
+    socketByConnectionId: Map<string, KuzzleWebSocket>;
+    logger: ReturnType<typeof global.kuzzle.log.child>;
+    constructor();
+    /**
+     * The uWebSockets application and the two parsed configuration blocks.
+     * All three are built by `init` — the first from the other two, which are
+     * themselves parsed out of a configuration only the entry point has — and
+     * every one of the seventeen reads below happens in a handler that the
+     * server registered, so none of them can run before `init` returned.
+     *
+     * Declaring them nullable and dereferencing them anyway is the shape
+     * `Protocol.entryPoint` had; these accessors answer the same way, once,
+     * instead of at each call site.
+     */
+    get server(): uWS.TemplatedApp;
+    get wsConfig(): JSONObject;
+    get httpConfig(): JSONObject;
+    init(entryPoint: NetworkEntryPoint): Promise<boolean>;
+    /** @deprecated pass the name to the constructor and call `init(entryPoint)` */
+    init(name: null, entryPoint: NetworkEntryPoint): 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>;
+    broadcast(data: JSONObject): void;
+    notify(data: JSONObject): void;
+    joinChannel(channel: string, connectionId: string): void;
+    leaveChannel(channel: string, connectionId: string): void;
+    disconnect(connectionId: string, message?: string | null): void;
+    wsOnUpgradeHandler(res: uWS.HttpResponse, req: uWS.HttpRequest, context: uWS.us_socket_context_t): void;
+    wsOnOpenHandler(socket: KuzzleWebSocket): void;
+    wsOnCloseHandler(socket: KuzzleWebSocket, code: number, message: ArrayBuffer): void;
+    wsOnMessageHandler(socket: KuzzleWebSocket, data: ArrayBuffer): Promise<void>;
     /**
      * Absorb as much of the backpressure buffer as possible
      * @param  {uWS.WebSocket} socket
      */
-    wsOnDrainHandler(socket: uWS.WebSocket<any>): void;
+    wsOnDrainHandler(socket: KuzzleWebSocket): void;
     /**
      * Forwards an error to a socket
      *
@@ -66,7 +75,7 @@ declare class HttpWsProtocol extends Protocol {
      * @param  {Error} error
      * @param  {String} requestId @optional
      */
-    wsSendError(socket: uWS.WebSocket<any>, connection: ClientConnection, error: Error, requestId: string): void;
+    wsSendError(socket: KuzzleWebSocket, connection: ClientConnection, error: KuzzleError, requestId?: string): void;
     /**
      * Sends a message immediately, or queue it up for later if backpressure built
      * up
@@ -74,7 +83,7 @@ declare class HttpWsProtocol extends Protocol {
      * @param  {uWS.WebSocket} socket
      * @param  {Buffer} payload
      */
-    wsSend(socket: uWS.WebSocket<any>, payload: Buffer): void;
+    wsSend(socket: KuzzleWebSocket, payload: Buffer): void;
     /**
      * @param  {uWS.HttpResponse} response
      * @param  {uWS.HttpRequest} request
@@ -87,16 +96,27 @@ declare class HttpWsProtocol extends Protocol {
      * @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;
+    httpReadData(message: HttpMessage, response: uWS.HttpResponse, cb: (error?: Error) => void): void;
+    httpParseContent(message: HttpMessage, content: Buffer, cb: (error?: Error) => void): Promise<void>;
+    /**
+     * Fills `message.content` from a multipart/form-data payload, file parts
+     * base64-encoded and the rest read as text.
+     *
+     * Returns false when a part is over the configured `maxFormFileSize`, leaving
+     * the caller to raise the error — a boolean rather than a throw so
+     * `httpParseContent` keeps answering through its callback, and split out of
+     * it to stay under the cognitive complexity ceiling the `.js` → `.ts` rename
+     * re-scores as new code.
+     */
+    private httpParseMultipart;
+    httpProcessRequest(response: uWS.HttpResponse, message: HttpMessage): void;
     /**
      *
      * @param {uWS.HttpRequest} request
      * @param {uWS.HttpResponse} response
      * @param {HttpMessage} message
      */
-    httpWriteRequestHeaders(request: uWS.HttpRequest, response: uWS.HttpResponse, message: HttpMessage): void;
+    httpWriteRequestHeaders(request: Request, response: uWS.HttpResponse, message: HttpMessage): void;
     /**
      * Send stream data thorugh the HTTP response
      * @param {HttpRequest} request
@@ -104,7 +124,7 @@ declare class HttpWsProtocol extends Protocol {
      * @param {uWS.HttpResponse} response
      * @param {HttpMessage} message
      */
-    httpSendStream(request: HttpRequest, response: uWS.HttpResponse, httpStream: HttpStream, message: HttpMessage): void;
+    httpSendStream(request: Request, response: uWS.HttpResponse, httpStream: HttpStream, message: HttpMessage): void;
     /**
      * Forward an error response to the client
      *
@@ -130,42 +150,13 @@ declare class HttpWsProtocol extends Protocol {
      * @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;
-        };
-    };
+    httpCompress(message: HttpMessage, data: Buffer, callback: (result: {
+        compressed: Buffer;
+        encoding: string;
+    }) => void): void;
+    httpUncompress(message: HttpMessage, payload: Buffer, cb: (error?: Error | null, result?: Buffer) => void): void;
+    httpUncompressStep(encodings: string[], payload: Buffer, cb: (error?: Error | null, result?: Buffer) => void, index: number): void;
+    parseWebSocketOptions(): JSONObject;
+    parseHttpOptions(): JSONObject;
 }
-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";
+export = HttpWsProtocol;