kuzzle 2.56.0 → 2.57.0-beta.2

package/dist/lib/core/debug/kuzzleDebugger.js

@@ -29,6 +29,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.KuzzleDebugger = void 0;
 const inspector_1 = __importDefault(require("inspector"));
 const kerror = __importStar(require("../../kerror"));
+/**
+ * A declared narrowing, not an assertion: `entryPoint.protocols` is typed by
+ * the base `Protocol`, and this is what makes the one member the debugger uses
+ * reachable without an `as`.
+ */
+function isSocketRegistry(protocol) {
+    return (typeof protocol === "object" &&
+        protocol !== null &&
+        "socketByConnectionId" in protocol &&
+        protocol.socketByConnectionId instanceof Map);
+}
 const DEBUGGER_EVENT = "kuzzle-debugger-event";
 class KuzzleDebugger {
     constructor() {
@@ -39,7 +50,11 @@ class KuzzleDebugger {
         this.events = new Map();
     }
     async init() {
-        this.httpWsProtocol = global.kuzzle.entryPoint.protocols.get("websocket");
+        const protocol = global.kuzzle.entryPoint.protocols.get("websocket");
+        // Narrowed with `in` rather than `instanceof`: `protocols` is typed by the
+        // base class, and importing the concrete one as a *value* would add a
+        // runtime edge to the graph — the shape TD-49 spent a PR removing.
+        this.httpWsProtocol = isSocketRegistry(protocol) ? protocol : undefined;
         this.inspector = new inspector_1.default.Session();
         // Remove connection id from the list of listeners for each event
         global.kuzzle.on("connection:remove", (connectionId) => {
@@ -102,8 +117,9 @@ class KuzzleDebugger {
         await global.kuzzle.ask("cluster:node:preventEviction", false);
         // Disable debug mode for all connected sockets that still have listeners
         if (this.httpWsProtocol) {
-            for (const eventName of this.events.keys()) {
-                for (const connectionId of this.events.get(eventName)) {
+            // `values()`: the key was read only to index the map back with it.
+            for (const connectionIds of this.events.values()) {
+                for (const connectionId of connectionIds) {
                     const socket = this.httpWsProtocol.socketByConnectionId.get(connectionId);
                     if (socket) {
                         socket.internal.debugSession = false;
@@ -220,21 +236,19 @@ class KuzzleDebugger {
         if (!this.debuggerStatus) {
             throw kerror.get("core", "debugger", "not_enabled");
         }
-        let resolve;
-        const promise = new Promise((res) => {
-            resolve = res;
-        });
-        this.inspector.post(method, params, (err, res) => {
-            if (err) {
-                resolve({
-                    error: JSON.stringify(Object.getOwnPropertyDescriptors(err)),
-                });
-            }
-            else {
-                resolve(res);
-            }
+        return new Promise((resolve) => {
+            this.inspector.post(method, params, (err, res) => {
+                if (err) {
+                    resolve({
+                        error: JSON.stringify(Object.getOwnPropertyDescriptors(err)),
+                    });
+                }
+                else {
+                    // The inspector answers `undefined` for a method with no result.
+                    resolve(res ?? {});
+                }
+            });
         });
-        return promise;
     }
     /**
      * Sends a direct notification to a websocket connection without having to listen to a specific room

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

@@ -1,29 +1,44 @@
 /// <reference types="node" />
-export class AccessLogger {
+import { Worker } from "node:worker_threads";
+import * as pino from "pino";
+import { KuzzleRequest } from "../../api/request";
+import type { ServerConfiguration } from "../../types";
+import type ClientConnection from "./clientConnection";
+/** What a protocol adds to an HTTP access log line */
+export interface AccessLogExtra {
+    method: string;
+    url: string;
+}
+declare class AccessLogger {
     isActive: boolean;
-    worker: Worker;
-    logger: import("../../kuzzle/Logger").Logger;
+    worker: Worker | null;
+    private readonly logger;
     init(): Promise<void>;
-    log(connection: any, request: any, extra: any): void;
+    log(connection: ClientConnection, request: KuzzleRequest, extra?: AccessLogExtra | null): void;
 }
-export class AccessLoggerWorker {
-    constructor(config: any, anonymousUserId: any);
-    config: any;
-    logger: pino.Logger<never, boolean>;
-    anonymousUserId: any;
+declare class AccessLoggerWorker {
+    config: ServerConfiguration;
+    private _logger;
+    anonymousUserId: string;
+    constructor(config: ServerConfiguration, anonymousUserId: string);
+    /**
+     * The pino transport, built by `initTransport()` — which `init()` calls
+     * before anything is listening. The three writes below read it unchecked.
+     */
+    get logger(): pino.Logger;
+    set logger(logger: pino.Logger);
     init(): void;
     initTransport(): void;
     /**
-     * @param {ClientConnection} connection
-     * @param {Request} request
-     * @param {String} size - response size, in bytes
-     * @param {Object} [extra]
+     * @param size - response size, in bytes
      */
-    logAccess(connection: ClientConnection, request: Request, size: string, extra?: any): void;
+    logAccess(connection: ClientConnection, request: KuzzleRequest, size: string, extra?: AccessLogExtra | null): void;
     /**
-     * @param  {ClientConnection} connection
+     * The user the access log line is attributed to: the already decoded and
+     * verified token stored in the request is preferred; without one, we have no
+     * verified identity to report.
      */
-    getIP(connection: ClientConnection): any;
+    private resolveUser;
+    getIP(connection: ClientConnection): string;
 }
-import { Worker } from "node:worker_threads";
-import pino = require("pino");
+export { AccessLogger, AccessLoggerWorker };

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

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,14 +19,47 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
+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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessLoggerWorker = exports.AccessLogger = void 0;
 // winston is CPU-hungry: isolating it in a worker thread allows for a more
 // efficient CPU resources management, and more performances in the end
-const { Worker, isMainThread, parentPort, workerData, } = require("worker_threads");
-const pino = require("pino");
-const moment = require("moment");
-const { KuzzleRequest } = require("../../api/request");
-const ALLOWED_TRANSPORTS = ["console", "elasticsearch", "file", "syslog"];
+const node_worker_threads_1 = require("node:worker_threads");
+const node_assert_1 = __importDefault(require("node:assert"));
+const moment_1 = __importDefault(require("moment"));
+const pino = __importStar(require("pino"));
+const request_1 = require("../../api/request");
+const ALLOWED_TRANSPORTS = new Set([
+    "console",
+    "elasticsearch",
+    "file",
+    "syslog",
+]);
 class AccessLogger {
     constructor() {
         this.isActive = false;
@@ -35,7 +69,7 @@ class AccessLogger {
     async init() {
         const config = global.kuzzle.config.server;
         for (const out of config.logs.transports) {
-            if (out.transport && !ALLOWED_TRANSPORTS.includes(out.transport)) {
+            if (out.transport && !ALLOWED_TRANSPORTS.has(out.transport)) {
                 this.logger.error(`Failed to initialize logger transport "${out.transport}": unsupported transport. Skipped.`);
             }
             else {
@@ -46,7 +80,7 @@ class AccessLogger {
             return;
         }
         const anonymous = await global.kuzzle.ask("core:security:user:anonymous:get");
-        this.worker = new Worker(__filename, {
+        this.worker = new node_worker_threads_1.Worker(__filename, {
             workerData: {
                 anonymousUserId: anonymous._id,
                 config,
@@ -69,6 +103,12 @@ class AccessLogger {
         const size = request.response
             ? Buffer.byteLength(JSON.stringify(request.response)).toString()
             : "-";
+        // `isActive` is what `init()` sets before building the worker, so a
+        // worker that is missing here means `init()` never ran — the same
+        // condition the early return above is for, said where it can be seen.
+        if (this.worker === null) {
+            return;
+        }
         try {
             this.worker.postMessage({
                 connection,
@@ -82,20 +122,37 @@ class AccessLogger {
         }
     }
 }
+exports.AccessLogger = AccessLogger;
 class AccessLoggerWorker {
     constructor(config, anonymousUserId) {
         this.config = config;
-        this.logger = null;
+        this._logger = null;
         this.anonymousUserId = anonymousUserId;
     }
+    /**
+     * The pino transport, built by `initTransport()` — which `init()` calls
+     * before anything is listening. The three writes below read it unchecked.
+     */
+    get logger() {
+        if (this._logger === null) {
+            throw new Error("[network] access logger used before init()");
+        }
+        return this._logger;
+    }
+    set logger(logger) {
+        this._logger = logger;
+    }
     init() {
         this.initTransport();
-        parentPort.on("message", ({ connection, extra, request, size }) => {
-            this.logAccess(connection, new KuzzleRequest(request.data, request.options), size, extra);
+        // This module is the worker's entry point: it only runs as a worker
+        // thread, and `parentPort` is null only in the thread that spawned one.
+        (0, node_assert_1.default)(node_worker_threads_1.parentPort !== null, "[network] the access logger worker has no parent port");
+        node_worker_threads_1.parentPort.on("message", ({ connection, extra, request, size }) => {
+            this.logAccess(connection, new request_1.KuzzleRequest(request.data, request.options), size, extra);
         });
     }
     initTransport() {
-        const transports = { targets: [] };
+        const targets = [];
         for (const conf of this.config.logs.transports) {
             if (conf.silent === true) {
                 continue;
@@ -103,7 +160,7 @@ class AccessLoggerWorker {
             // Guarantee default transport is 'console' and retro compatibility with winston options
             switch (conf.transport || conf.preset || "console") {
                 case "console":
-                    transports.targets.push({
+                    targets.push({
                         level: conf.level || "info",
                         options: {
                             destination: 1,
@@ -112,14 +169,14 @@ class AccessLoggerWorker {
                     });
                     break;
                 case "elasticsearch":
-                    transports.targets.push({
+                    targets.push({
                         level: conf.level || "info",
-                        options: Object.assign({}, conf.options),
+                        options: { ...conf.options },
                         target: "pino-elasticsearch",
                     });
                     break;
                 case "file":
-                    transports.targets.push({
+                    targets.push({
                         level: conf.level || "info",
                         options: {
                             append: conf.options?.append ?? true,
@@ -135,20 +192,17 @@ class AccessLoggerWorker {
             // If a pino transport configuration is used, we'll try to use it as-is and
             // assume the user installed the necessary dependencies in his Kuzzle application
             if (typeof conf.target === "string" && conf.target !== "") {
-                transports.targets.push({
+                targets.push({
                     level: conf.level || "info",
                     options: conf.options || {},
                     target: conf.target,
                 });
             }
         }
-        this.logger = pino.pino(pino.transport(transports));
+        this.logger = pino.pino(pino.transport({ targets }));
     }
     /**
-     * @param {ClientConnection} connection
-     * @param {Request} request
-     * @param {String} size - response size, in bytes
-     * @param {Object} [extra]
+     * @param size - response size, in bytes
      */
     logAccess(connection, request, size, extra = null) {
         if (this.config.logs.accessLogFormat === "logstash") {
@@ -164,57 +218,23 @@ class AccessLoggerWorker {
             });
             return;
         }
-        // user init: prioritize the already decoded and verified token stored in
-        // the request
-        // If not available, then that may mean that we didn't verify the user yet,
-        // so we have to decode any provided token
-        let user = null;
-        if (request.context.token !== null) {
-            user =
-                request.context.token.userId === this.anonymousUserId
-                    ? "(anonymous)"
-                    : request.context.token.userId;
-        }
+        const user = this.resolveUser(request);
         // = apache combined
         const protocol = connection.protocol.toUpperCase();
         let url;
         let verb = "DO";
-        if (connection.protocol.indexOf("HTTP/") === 0) {
+        // `extra` carries the HTTP method and url, and only an HTTP connection
+        // has one: the two were read on the strength of the protocol name alone.
+        if (connection.protocol.startsWith("HTTP/") && extra !== null) {
             verb = extra.method;
             url = extra.url;
         }
         // for other protocols than http, we rebuild a pseudo url
         else {
-            url = `/${request.input.controller}/${request.input.action}`;
-            if (request.input.args.index) {
-                url += `/${request.input.args.index}`;
-            }
-            if (request.input.args.collection) {
-                url += `/${request.input.args.collection}`;
-            }
-            if (request.input.args._id) {
-                url += `/${request.input.args._id}`;
-            }
-            let queryString = "";
-            for (const k of Object.keys(request.input.args)) {
-                if (k === "_id" || k === "index" || k === "collection") {
-                    continue;
-                }
-                const val = request.input.args[k];
-                if (queryString.length > 0) {
-                    queryString += "&";
-                }
-                queryString += `${k}=${typeof val === "object" ? JSON.stringify(val) : val}`;
-            }
-            if (queryString.length > 0) {
-                url += `?${queryString}`;
-            }
-        }
-        if (user === null) {
-            user = "(unknown)";
+            url = buildPseudoUrl(request);
         }
         const ip = this.getIP(connection);
-        const when = moment().format("DD/MMM/YYYY:HH:mm:ss ZZ");
+        const when = (0, moment_1.default)().format("DD/MMM/YYYY:HH:mm:ss ZZ");
         const status = request.status || "-";
         const referer = connection.headers.referer
             ? `"${connection.headers.referer}"`
@@ -225,26 +245,68 @@ class AccessLoggerWorker {
         this.logger.info({ namespace: "kuzzle:accessLogs", nodeId: global.kuzzle.id }, `${ip} - ${user} [${when}] "${verb} ${url} ${protocol}" ${status} ${size} ${referer} ${agent}`);
     }
     /**
-     * @param  {ClientConnection} connection
+     * The user the access log line is attributed to: the already decoded and
+     * verified token stored in the request is preferred; without one, we have no
+     * verified identity to report.
      */
+    resolveUser(request) {
+        const { token } = request.context;
+        if (token === null) {
+            return "(unknown)";
+        }
+        const user = token.userId === this.anonymousUserId ? "(anonymous)" : token.userId;
+        // `??` rather than a `=== null` test: a token with no userId at all used
+        // to log the string "undefined"
+        return user ?? "(unknown)";
+    }
     getIP(connection) {
         const { ips } = connection;
         if (ips.length === 0) {
             return "-";
         }
         const idx = Math.max(0, ips.length - 1 - this.config.logs.accessLogIpOffset);
-        return ips[idx];
+        // `ips` is non-empty here — the caller builds it from the connection —
+        // and an offset past its start is clamped to 0 above.
+        return ips[idx] ?? "";
+    }
+}
+exports.AccessLoggerWorker = AccessLoggerWorker;
+/**
+ * For protocols other than http, we rebuild a pseudo url out of the request's
+ * controller, action and arguments.
+ */
+function buildPseudoUrl(request) {
+    let url = `/${request.input.controller}/${request.input.action}`;
+    if (request.input.args.index) {
+        url += `/${request.input.args.index}`;
+    }
+    if (request.input.args.collection) {
+        url += `/${request.input.args.collection}`;
+    }
+    if (request.input.args._id) {
+        url += `/${request.input.args._id}`;
+    }
+    let queryString = "";
+    for (const k of Object.keys(request.input.args)) {
+        if (k === "_id" || k === "index" || k === "collection") {
+            continue;
+        }
+        const val = request.input.args[k];
+        if (queryString.length > 0) {
+            queryString += "&";
+        }
+        queryString += `${k}=${typeof val === "object" ? JSON.stringify(val) : val}`;
+    }
+    if (queryString.length > 0) {
+        url += `?${queryString}`;
     }
+    return url;
 }
-if (!isMainThread) {
-    // Needed for instantiating a serialized KuzzleRequest object
-    global.kuzzle = { id: workerData.kuzzleId };
-    const worker = new AccessLoggerWorker(workerData.config, workerData.anonymousUserId);
+if (!node_worker_threads_1.isMainThread) {
+    // Needed for instantiating a serialized KuzzleRequest object: the worker
+    // thread has no Kuzzle instance of its own, only the node id.
+    global.kuzzle = { id: node_worker_threads_1.workerData.kuzzleId };
+    const worker = new AccessLoggerWorker(node_worker_threads_1.workerData.config, node_worker_threads_1.workerData.anonymousUserId);
     worker.init();
 }
-// Exposing the worker isn't necessary for production code: this is only
-// useful to make this class testable. I usually don't like it when tests have a
-// say in how the code should be written, but in this particular case, I see
-// no other way to correctly test this.
-module.exports = { AccessLogger, AccessLoggerWorker };
 //# sourceMappingURL=accessLogger.js.map

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

@@ -1,15 +1,17 @@
-export = ClientConnection;
+import type { JSONObject } from "../../types/JSONObject";
 /**
- * @class ClientConnection
- * @param {string} protocol - The protocol used (http, websocket, mqtt etc)
- * @param {Array.<string>} ips - The list of forwarded ips (= X-Forwarded-For http header + the final ip, i.e. client, proxy1, proxy2, etc.)
- * @param {object} [headers] - Optional extra key-value object. I.e., for http, will receive the request headers
+ * @param protocol - The protocol used (http, websocket, mqtt etc)
+ * @param ips - The list of forwarded ips (= X-Forwarded-For http header + the
+ *              final ip, i.e. client, proxy1, proxy2, etc.)
+ * @param headers - Optional extra key-value object. I.e., for http, will
+ *                  receive the request headers
  */
 declare class ClientConnection {
-    constructor(protocol: any, ips: any, headers?: any, internal?: any);
-    id: string;
-    protocol: any;
-    headers: any;
-    internal: any;
-    ips: any[];
+    readonly id: string;
+    readonly protocol: string;
+    readonly headers: JSONObject;
+    readonly internal: JSONObject;
+    readonly ips: string[];
+    constructor(protocol: string, ips: string[], headers?: JSONObject | null, internal?: JSONObject | null);
 }
+export = ClientConnection;

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

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,14 +19,37 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const { isPlainObject } = require("../../util/safeObject");
-const uuid = require("uuid");
+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;
+};
+const uuid = __importStar(require("uuid"));
+const safeObject_1 = require("../../util/safeObject");
 /**
- * @class ClientConnection
- * @param {string} protocol - The protocol used (http, websocket, mqtt etc)
- * @param {Array.<string>} ips - The list of forwarded ips (= X-Forwarded-For http header + the final ip, i.e. client, proxy1, proxy2, etc.)
- * @param {object} [headers] - Optional extra key-value object. I.e., for http, will receive the request headers
+ * @param protocol - The protocol used (http, websocket, mqtt etc)
+ * @param ips - The list of forwarded ips (= X-Forwarded-For http header + the
+ *              final ip, i.e. client, proxy1, proxy2, etc.)
+ * @param headers - Optional extra key-value object. I.e., for http, will
+ *                  receive the request headers
  */
 class ClientConnection {
     constructor(protocol, ips, headers = null, internal = null) {
@@ -37,10 +61,10 @@ class ClientConnection {
             throw new TypeError(`Expected ips to be an Array, got ${typeof ips}`);
         }
         this.ips = ips;
-        if (isPlainObject(headers)) {
+        if ((0, safeObject_1.isPlainObject)(headers)) {
             this.headers = headers;
         }
-        if (isPlainObject(internal)) {
+        if ((0, safeObject_1.isPlainObject)(internal)) {
             this.internal = internal;
         }
         Object.freeze(this);

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

@@ -1,7 +1,16 @@
-export = Context;
+/// <reference types="lib/types/debug" />
+import { BadRequestError, ExternalServiceError, ForbiddenError, GatewayTimeoutError, InternalError as KuzzleInternalError, KuzzleError, NotFoundError, PartialError, PluginImplementationError, PreconditionError, ServiceUnavailableError, SizeLimitError, TooManyRequestsError, UnauthorizedError } from "../../kerror/errors";
+import { Request, RequestContext, RequestInput } from "../../api/request";
+import ClientConnection from "./clientConnection";
+import ProtocolBase from "./protocols/protocol";
+type LogLevel = "silly" | "debug" | "verbose" | "info" | "warn" | "error";
+/**
+ * The object a protocol plugin is initialized with: the constructors and the
+ * loggers it is allowed to reach, rather than the Kuzzle instance itself.
+ */
 declare class Context {
     ClientConnection: typeof ClientConnection;
-    debug: any;
+    debug: import("debug").Debugger;
     errors: {
         BadRequestError: typeof BadRequestError;
         ExternalServiceError: typeof ExternalServiceError;
@@ -19,24 +28,10 @@ declare class Context {
         UnauthorizedError: typeof UnauthorizedError;
     };
     Protocol: typeof ProtocolBase;
-    Request: any;
-    RequestContext: any;
-    RequestInput: any;
-    log: {};
+    Request: typeof Request;
+    RequestContext: typeof RequestContext;
+    RequestInput: typeof RequestInput;
+    log: Record<LogLevel, (message: string, ...args: unknown[]) => void>;
+    constructor();
 }
-import ClientConnection = require("./clientConnection");
-import { BadRequestError } from "../../kerror/errors/badRequestError";
-import { ExternalServiceError } from "../../kerror/errors/externalServiceError";
-import { ForbiddenError } from "../../kerror/errors/forbiddenError";
-import { GatewayTimeoutError } from "../../kerror/errors/gatewayTimeoutError";
-import { InternalError as KuzzleInternalError } from "../../kerror/errors/internalError";
-import { KuzzleError } from "../../kerror/errors/kuzzleError";
-import { NotFoundError } from "../../kerror/errors/notFoundError";
-import { PartialError } from "../../kerror/errors/partialError";
-import { PluginImplementationError } from "../../kerror/errors/pluginImplementationError";
-import { PreconditionError } from "../../kerror/errors/preconditionError";
-import { ServiceUnavailableError } from "../../kerror/errors/serviceUnavailableError";
-import { SizeLimitError } from "../../kerror/errors/sizeLimitError";
-import { TooManyRequestsError } from "../../kerror/errors/tooManyRequestsError";
-import { UnauthorizedError } from "../../kerror/errors/unauthorizedError";
-import ProtocolBase = require("./protocols/protocol");
+export = Context;