kuzzle 2.49.1 → 2.50.0-beta.4

package/dist/lib/api/funnel.d.ts

@@ -0,0 +1,183 @@
+export = Funnel;
+/**
+ * @class Funnel
+ */
+declare class Funnel {
+    overloaded: boolean;
+    concurrentRequests: number;
+    controllers: Map<any, any>;
+    pendingRequestsQueue: Deque<any>;
+    pendingRequestsById: Map<any, any>;
+    lastOverloadTime: number;
+    overloadWarned: boolean;
+    lastWarningTime: number;
+    rateLimiter: RateLimiter;
+    lastDumpedErrors: {};
+    sdkCompatibility: any;
+    logger: import("../kuzzle/Logger").Logger;
+    init(): Bluebird<any[]>;
+    loadDocumentEventAliases(): void;
+    documentEventAliases: import("../config/documentEventAliases").EventAliases;
+    /**
+     * Asks the overload-protection system for an execution slot.
+     *
+     * Returns immediately true if the request can be
+     * executed.
+     *
+     * Otherwise, false is returned, and the caller MUST
+     * stop the request execution.
+     * In this case:
+     *   - if it can be bufferized, then the request is left untouched
+     *     and the executor function will be called later when a slot
+     *     becomes available
+     *   - if the buffer limit has been reached, a ServiceUnavailable error
+     *     is set to the request. In that case, the executor is free to
+     *     retry submitting the request later, or to abort it and return
+     *     the request as it is
+     *
+     * @param {Function} fn - The function to be executed as soon as the slot is
+     *                        available.
+     * @param {Object} context - The execution context of the `fn` param.
+     * @param {String} request - The request object that will be passed as
+     *                           argument to `fn`.
+     * @returns {Boolean} - A boolean telling whether the request has been
+     *                      immediately executed or not.
+     */
+    throttle(fn: Function, context: any, request: string): boolean;
+    /**
+     * Execute the API request by
+     * 1/ check domain from origin header
+     * 2/ asking for a request slot,
+     * 3/ verify that the user is still connected
+     * 4/ checking if the requesting user has the right credentials
+     * 5/ send the request itself to the corresponding controller+action
+     *
+     * @param {Request} request
+     * @param {Function} callback
+     * @returns {Number} -1: request delayed, 0: request processing, 1: error
+     */
+    execute(request: Request, callback: Function): number;
+    /**
+     * Checks if an error is worth dumping Kuzzle. If so,
+     * creates a dump.
+     *
+     * @param {KuzzleError|*} err
+     */
+    handleErrorDump(err: KuzzleError | any): void;
+    /**
+     * Checks if a user has the necessary rights to execute the action
+     *
+     * @param {Request} request
+     * @returns {Promise<Request>}
+     */
+    checkRights(request: Request): Promise<Request>;
+    _isLogin(request: any): boolean;
+    /**
+     * Executes the request immediately.
+     * /!\ To be used only by methods having already passed the overload check.
+     *
+     * @param {KuzzleRequest} request
+     * @returns {Promise}
+     */
+    processRequest(request: KuzzleRequest): Promise<any>;
+    /**
+     * Triggers generic:document:* events
+     *
+     * @warning Critical code section
+     *
+     * @param {KuzzleRequest} request
+     * @param {String} prefix
+     *
+     * @returns {Promise<KuzzleRequest>}
+     */
+    performDocumentAlias(request: KuzzleRequest, prefix: string): Promise<KuzzleRequest>;
+    /**
+     * Exposes API requests execution to plugins
+     *
+     * Similar to execute, except that:
+     *   - plugin requests do not trigger API events
+     *   - plugin requests are not counted towards requests statistics
+     *   - the overload protection mechanism is disabled
+     *
+     * @param {KuzzleRequest} request
+     * @returns {Promise}
+     */
+    executePluginRequest(request: KuzzleRequest): Promise<any>;
+    handleProcessRequestError(modifiedRequest: any, request: any, error: any): Promise<any>;
+    /**
+     * Helper function meant to normalize event names
+     * by retrieving controller aliases' original names.
+     *
+     * @param {Request} Executed request
+     * @param {string} prefix - event prefix
+     * @returns {string} event name
+     */
+    getEventName(request: any, prefix: string): string;
+    /**
+     * Returns the number of remaining requests
+     *
+     * @returns {number}
+     */
+    get remainingRequests(): number;
+    /**
+     * Return the controller corresponding to the action asked by the request
+     *
+     * @param  {Request} request
+     * @returns {Object} controller object
+     * @throws {BadRequestError} If the asked controller or action is unknown
+     */
+    getController(request: Request): any;
+    /**
+     * Tell if the controller is a native controller or not
+     * @param  {String}  controller
+     * @returns {Boolean}
+     */
+    isNativeController(controller: string): boolean;
+    /**
+     * Returns inner metrics from the Funnel
+     * @returns {Object}
+     */
+    metrics(): any;
+    /**
+     * If the request is coming from an official SDK,
+     * then checks the compatibility of the SDK against current Kuzzle version.
+     *
+     * @param {Request} request
+     *
+     * @throws
+     */
+    _checkSdkVersion(request: Request): void;
+    /**
+     * Populates the given request with the error and calls the callback
+     *
+     * @param {Error} error
+     * @param {Request} request
+     * @param {boolean} asError - if set to true, calls the callback with its first argument as error
+     * @param {Function} callback
+     * @returns {null}
+     * @private
+     */
+    private _executeError;
+    /**
+     * Background task. Checks if there are any requests in cache, and replay them
+     * if Kuzzle is not overloaded anymore,
+     */
+    _playPendingRequests(): void;
+    /**
+     * Eventually wrap an error into a PluginImplementationError
+     * @param  {Request} request
+     * @param  {Error} error
+     * @returns {KuzzleError}
+     */
+    _wrapError(request: Request, error: Error): KuzzleError;
+    /**
+     * Verifies if requests sent from a specific origin are allowed
+     * @param {string} origin
+     * @returns
+     */
+    _isOriginAuthorized(origin: string): boolean;
+}
+import Deque = require("denque");
+import RateLimiter = require("./rateLimiter");
+import Bluebird = require("bluebird");
+import { KuzzleError } from "../kerror/errors/kuzzleError";