kuzzle 2.49.1 → 2.50.0-beta.4

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

@@ -0,0 +1,193 @@
+/*
+ * 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");
+const HttpRouter = require("./httpRouter");
+const { removeStacktrace } = require("../../util/stackTrace");
+const kuzzleStateEnum = require("../../kuzzle/kuzzleStateEnum");
+/**
+ * @class Router
+ * @property action
+ * @param {Kuzzle} kuzzle
+ */
+class Router {
+    constructor() {
+        this.connections = new Map();
+        this.http = new HttpRouter();
+        this.logger = global.kuzzle.log.child("core:network:router");
+    }
+    /**
+     * Declares a new connection attached to a network protocol.
+     *
+     * @param {RequestContext} requestContext
+     */
+    newConnection(requestContext) {
+        if (!requestContext.connection.id || !requestContext.connection.protocol) {
+            this.logger.error(kerror.get("protocol", "runtime", "invalid_connection", JSON.stringify(requestContext)));
+        }
+        else {
+            this.connections.set(requestContext.connection.id, requestContext);
+            global.kuzzle.statistics.newConnection(requestContext);
+        }
+    }
+    /**
+     * Removes a connection from the connection pool.
+     *
+     * @param {RequestContext} requestContext
+     */
+    removeConnection(requestContext) {
+        const connId = requestContext.connection.id;
+        if (!connId || !requestContext.connection.protocol) {
+            this.logger.error(kerror.get("protocol", "runtime", "invalid_connection", JSON.stringify(requestContext.context)));
+            return;
+        }
+        if (!this.connections.has(connId)) {
+            this.logger.error(kerror.get("protocol", "runtime", "unknown_connection", JSON.stringify(connId)));
+            return;
+        }
+        this.connections.delete(connId);
+        global.kuzzle.statistics.dropConnection(requestContext);
+    }
+    /**
+     * Check that the provided connection id executing a request is still alive
+     *
+     * @param  {RequestContext} requestContext
+     */
+    isConnectionAlive(requestContext) {
+        // Check only defined connection identifiers (some protocols might
+        // not have one)
+        return (requestContext.connection.id === null ||
+            this.connections.has(requestContext.connection.id));
+    }
+    /**
+     * Initializes the HTTP routes for the Kuzzle HTTP API.
+     */
+    init() {
+        // Register API and plugin routes
+        const routes = [
+            ...global.kuzzle.config.http.routes,
+            ...global.kuzzle.pluginsManager.routes,
+        ];
+        this.http.post("_query", (request, cb) => {
+            // We need to build a new request from the body
+            // and we also need to keep the original request context
+            const requestPayload = request.input.body;
+            if (request.input.jwt && requestPayload.jwt === undefined) {
+                requestPayload.jwt = request.input.jwt;
+            }
+            const apiRequest = new Request(requestPayload, request.serialize().options);
+            this._executeFromHttp("post", apiRequest, cb);
+        });
+        this.http.get("_healthcheck", (request, cb) => {
+            request.response.configure({
+                status: 200,
+            });
+            /**
+             * By avoiding using the funnel, we avoid the request to be logged
+             * This is useful for ochestrators healthchecks
+             */
+            cb(request);
+        });
+        this.http.get("_ready", (request, cb) => {
+            let status = 200;
+            if (global.kuzzle.state !== kuzzleStateEnum.RUNNING ||
+                global.kuzzle.funnel.overloaded) {
+                status = 503;
+            }
+            request.response.configure({
+                status: status,
+            });
+            /**
+             * By avoiding using the funnel, we avoid the request to be logged
+             * This is useful for ochestrators healthchecks
+             */
+            cb(request);
+        });
+        for (const route of routes) {
+            const verb = route.verb.toLowerCase();
+            this.http[verb](route.path, (request, cb) => {
+                request.input.controller = route.controller;
+                request.input.action = route.action;
+                if (route.deprecated) {
+                    const { deprecated: { since, message }, } = route;
+                    request.addDeprecation(since, message);
+                }
+                this._executeFromHttp(route.verb, request, cb);
+            });
+        }
+        /**
+         * Returns inner metrics from the router
+         * @returns {Object}
+         */
+        global.kuzzle.onAsk("core:network:router:metrics", () => this.metrics());
+    }
+    /**
+     * Returns the metrics of the router
+     * @returns {Object}
+     */
+    metrics() {
+        const connectionsByProtocol = {};
+        for (const connection of this.connections.values()) {
+            const protocol = connection.connection.protocol.toLowerCase();
+            if (protocol === "internal") {
+                continue;
+            }
+            if (connectionsByProtocol[protocol] === undefined) {
+                connectionsByProtocol[protocol] = 0;
+            }
+            connectionsByProtocol[protocol]++;
+        }
+        return {
+            connections: connectionsByProtocol,
+        };
+    }
+    /**
+     * Transmit HTTP requests to the funnel controller and forward its response
+     * back to the client
+     *
+     * @param {String} verb
+     * @param {Request} request - includes URL and POST query data
+     * @param {function} cb - callback to invoke with the result
+     */
+    _executeFromHttp(verb, request, cb) {
+        global.kuzzle.pipe(`http:${verb}`, request, (error, mutatedRequest) => {
+            if (error) {
+                request.setError(error);
+                cb(request);
+            }
+            else {
+                global.kuzzle.funnel.execute(mutatedRequest, (err, result) => {
+                    const _res = result || request;
+                    if (err && !_res.error) {
+                        _res.setError(err);
+                    }
+                    cb(removeStacktrace(_res));
+                });
+            }
+        });
+    }
+}
+/**
+ * @type {RouterController}
+ */
+module.exports = Router;
+//# sourceMappingURL=router.js.map

package/dist/lib/core/plugin/plugin.d.ts

@@ -0,0 +1,56 @@
+export = Plugin;
+declare class Plugin {
+    static loadFromDirectory(pluginPath: any): Plugin;
+    static checkName(name: any): boolean;
+    static checkControllerDefinition(name: any, definition: any, { application }?: {
+        application?: boolean;
+    }): void;
+    constructor(instance: any, { name, application, deprecationWarning }?: {
+        name: any;
+        application?: boolean;
+        deprecationWarning?: boolean;
+    });
+    _instance: any;
+    _application: boolean;
+    _initCalled: boolean;
+    _config: {};
+    _context: PluginContext;
+    _version: any;
+    _name: string;
+    _manifest: any;
+    _deprecationWarning: boolean;
+    set name(name: string);
+    get name(): string;
+    init(name: any): void;
+    set config(config: {});
+    get config(): {};
+    info(): {
+        version: any;
+        controllers: any[];
+        hooks: any[];
+        manifest: any;
+        pipes: any[];
+        routes: any[];
+        strategies: any[];
+        imports: {};
+    } | {
+        name: string;
+        version: any;
+        commit: any;
+        controllers: any;
+        pipes: string[];
+        hooks: string[];
+    };
+    printDeprecation(message: any): void;
+    get instance(): any;
+    get context(): PluginContext;
+    get application(): boolean;
+    get logPrefix(): string;
+    set version(version: any);
+    get version(): any;
+    set deprecationWarning(value: boolean);
+    get deprecationWarning(): boolean;
+    set manifest(manifest: any);
+    get manifest(): any;
+}
+import { PluginContext } from "./pluginContext";

package/dist/lib/core/plugin/plugin.js

@@ -0,0 +1,282 @@
+/*
+ * 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 path = require("path");
+const fs = require("fs");
+const semver = require("semver");
+const { PluginContext } = require("./pluginContext");
+const PrivilegedPluginContext = require("./privilegedContext");
+const kerror = require("../../kerror");
+const errorCodes = require("../../kerror/codes");
+const Manifest = require("./pluginManifest");
+const { has, isPlainObject } = require("../../util/safeObject");
+const defaultConfig = require("../../config/default.config");
+const assertionError = kerror.wrap("plugin", "assert");
+const runtimeError = kerror.wrap("plugin", "runtime");
+const PLUGIN_NAME_REGEX = /^[a-z-\d]+$/;
+const HTTP_VERBS = ["get", "head", "post", "put", "delete", "patch", "options"];
+class Plugin {
+    constructor(instance, { name, application = false, deprecationWarning = true } = {}) {
+        this._instance = instance;
+        this._application = application;
+        this._initCalled = false;
+        this._config = {};
+        this._context = null;
+        this._version = instance.version || "";
+        this._name = "";
+        this._manifest = instance._manifest || null;
+        this._deprecationWarning = deprecationWarning;
+        if (name) {
+            this.name = name;
+        }
+    }
+    init(name) {
+        this.name = name;
+        if (global.kuzzle.config.plugins[this.name]) {
+            this.config = JSON.parse(JSON.stringify(global.kuzzle.config.plugins[this.name]));
+        }
+        // check plugin privileged prerequisites
+        // user need to acknowledge privileged mode in plugin configuration
+        if (this.config.privileged) {
+            if (!this.manifest || !this.manifest.privileged) {
+                throw assertionError.get("privileged_not_supported", this.name);
+            }
+        }
+        else if (this.manifest && this.manifest.privileged) {
+            throw assertionError.get("privileged_not_set", this.name);
+        }
+        if (this.manifest && this.manifest.kuzzleVersion) {
+            if (!semver.satisfies(global.kuzzle.config.version, this.manifest.kuzzleVersion, { includePrerelease: true })) {
+                throw kerror.get("plugin", "manifest", "version_mismatch", this.name, global.kuzzle.config.version, this.manifest.kuzzleVersion);
+            }
+        }
+        this._context = this.config.privileged
+            ? new PrivilegedPluginContext(this.name)
+            : new PluginContext(this.name);
+    }
+    info() {
+        /* eslint-disable sort-keys */
+        if (this.application) {
+            return {
+                name: this.name,
+                version: this.version,
+                commit: this.commit,
+                controllers: this.instance.api,
+                pipes: Object.keys(this.instance.pipes),
+                hooks: Object.keys(this.instance.hooks),
+            };
+        }
+        const description = {
+            version: this.version,
+            controllers: [],
+            hooks: [],
+            manifest: this.manifest,
+            pipes: [],
+            routes: [],
+            strategies: [],
+            imports: {},
+        };
+        /* eslint-enable sort-keys */
+        if (has(this.instance, "imports")) {
+            description.imports = Object.keys(this.instance.imports);
+        }
+        if (has(this.instance, "hooks")) {
+            description.hooks = Object.keys(this.instance.hooks);
+        }
+        if (has(this.instance, "pipes")) {
+            description.pipes = Object.keys(this.instance.pipes);
+        }
+        if (has(this.instance, "controllers")) {
+            description.controllers = Object.keys(this.instance.controllers).map((controller) => `${this.name}/${controller}`);
+        }
+        if (has(this.instance, "routes")) {
+            description.routes = this.instance.routes;
+        }
+        if (has(this.instance, "strategies")) {
+            description.strategies = Object.keys(this.instance.strategies);
+        }
+        return description;
+    }
+    printDeprecation(message) {
+        if (this.deprecationWarning) {
+            global.kuzzle.log.warn(`${this.logPrefix} ${message}`);
+        }
+    }
+    // getters/setters ===========================================================
+    get instance() {
+        return this._instance;
+    }
+    get context() {
+        return this._context;
+    }
+    get application() {
+        return this._application;
+    }
+    get logPrefix() {
+        return `[${this.name}]`;
+    }
+    get config() {
+        return this._config;
+    }
+    set config(config) {
+        this._config = config;
+    }
+    get version() {
+        return this._version;
+    }
+    set version(version) {
+        this._version = version;
+    }
+    get deprecationWarning() {
+        return this._deprecationWarning;
+    }
+    set deprecationWarning(value) {
+        this._deprecationWarning = value;
+    }
+    get name() {
+        return this._name;
+    }
+    set name(name) {
+        if (!this.constructor.checkName(name)) {
+            this.printDeprecation("Plugin names should be in kebab-case. This behavior will be enforced in futur versions of Kuzzle.");
+        }
+        this._name = name;
+    }
+    get manifest() {
+        return this._manifest;
+    }
+    set manifest(manifest) {
+        this._manifest = manifest;
+    }
+    // static methods ============================================================
+    static loadFromDirectory(pluginPath) {
+        if (!fs.statSync(pluginPath).isDirectory()) {
+            throw assertionError.get("cannot_load", pluginPath, "Not a directory.");
+        }
+        let plugin;
+        let PluginClass = {};
+        try {
+            PluginClass = require(pluginPath);
+            const pluginInstance = new PluginClass();
+            plugin = new Plugin(pluginInstance);
+        }
+        catch (error) {
+            if (error.message.match(/not a constructor/i)) {
+                throw assertionError.get("not_a_constructor", PluginClass.name);
+            }
+            throw runtimeError.getFrom(error, "unexpected_error", error.message);
+        }
+        // load manifest
+        plugin.manifest = new Manifest(pluginPath);
+        plugin.manifest.load();
+        plugin.name = plugin.manifest.name;
+        // load plugin version if exists
+        const packageJsonPath = path.join(pluginPath, "package.json");
+        if (fs.existsSync(packageJsonPath) && !plugin.version) {
+            plugin.version = require(packageJsonPath).version;
+        }
+        // load customs errors configuration file
+        if (plugin.manifest.raw.errors) {
+            try {
+                // we use the manifest name instead of the lowerCased plugin name
+                // to ensure to match the plugin original name in the configuration
+                const config = global.kuzzle.config[plugin.manifest.name];
+                const pluginCode = config && config._pluginCode ? config._pluginCode : 0x00;
+                errorCodes.loadPluginsErrors(plugin.manifest.raw, pluginCode);
+                global.kuzzle.log.info(`${plugin.logPrefix} Custom errors successfully loaded.`);
+            }
+            catch (err) {
+                if (err.message.match(/Error configuration file/i) ||
+                    err instanceof SyntaxError) {
+                    throw kerror.getFrom(err, "plugin", "manifest", "invalid_errors", plugin.manifest.name, err.message);
+                }
+                throw err;
+            }
+        }
+        // check if the plugin exposes a "init" method
+        if (typeof plugin.instance.init !== "function") {
+            throw assertionError.get("init_not_found", plugin.name);
+        }
+        return plugin;
+    }
+    static checkName(name) {
+        return PLUGIN_NAME_REGEX.test(name);
+    }
+    static checkControllerDefinition(name, definition, { application = false } = {}) {
+        if (typeof name !== "string") {
+            throw assertionError.get("invalid_controller_definition", "Controller name must be a string");
+        }
+        if (!isPlainObject(definition)) {
+            throw assertionError.get("invalid_controller_definition", name, "Controller definition must be an object");
+        }
+        if (!isPlainObject(definition.actions)) {
+            throw assertionError.get("invalid_controller_definition", name, 'Controller definition "actions" property must be an object');
+        }
+        for (const [action, actionDefinition] of Object.entries(definition.actions)) {
+            if (!global.app.config.content.controllers?.definition
+                ?.allowAdditionalActionProperties ??
+                defaultConfig.controllers.definition.allowAdditionalActionProperties) {
+                const actionProperties = Object.keys(actionDefinition).filter((prop) => prop !== "handler" && prop !== "http");
+                if (actionProperties.length > 0) {
+                    throw assertionError.get("invalid_controller_definition", name, `action "${action}" has invalid properties: ${actionProperties.join(", ")}`);
+                }
+            }
+            if (typeof action !== "string") {
+                throw assertionError.get("invalid_controller_definition", name, "action names must be strings");
+            }
+            if (typeof actionDefinition.handler !== "function") {
+                throw assertionError.get("invalid_controller_definition", name, `action "${action}" handler must be a function`);
+            }
+            if (actionDefinition.http) {
+                if (!Array.isArray(actionDefinition.http)) {
+                    throw assertionError.get("invalid_controller_definition", name, `action "${action}" http definition must be an array`);
+                }
+                for (const route of actionDefinition.http) {
+                    if (typeof route.verb !== "string" || route.verb.length === 0) {
+                        throw assertionError.get("invalid_controller_definition", name, `action "${action}" http "verb" property must be a non-empty string`);
+                    }
+                    if (!HTTP_VERBS.includes(route.verb.toLowerCase())) {
+                        throw assertionError.get("invalid_controller_definition", name, `action "${action}" http verb "${route.verb}" is not a valid http verb`);
+                    }
+                    checkHttpRouteProperties(route, action, name, application);
+                    const routeProperties = Object.keys(route);
+                    if (routeProperties.length > 3) {
+                        routeProperties.splice(routeProperties.indexOf("url"), 1);
+                        routeProperties.splice(routeProperties.indexOf("path"), 1);
+                        routeProperties.splice(routeProperties.indexOf("verb"), 1);
+                        routeProperties.splice(routeProperties.indexOf("openapi"), 1);
+                        throw assertionError.get("invalid_controller_definition", name, `action "${action}" has invalid http properties: ${routeProperties.join(", ")}`);
+                    }
+                }
+            }
+        }
+    }
+}
+function checkHttpRouteProperties(route, action, name, application) {
+    if (typeof route.path !== "string" || route.path.length === 0) {
+        if (!application && typeof route.url === "string" && route.url.length > 0) {
+            return;
+        }
+        throw assertionError.get("invalid_controller_definition", name, `action "${action}" http "path" property must be a non-empty string`);
+    }
+}
+module.exports = Plugin;
+//# sourceMappingURL=plugin.js.map

package/{lib → dist/lib}/core/plugin/pluginContext.js

@@ -48,6 +48,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PluginContext = void 0;
 const bluebird_1 = __importDefault(require("bluebird"));
+const lodash_1 = __importDefault(require("lodash"));
 const KoncordeWrapper_1 = require("../shared/KoncordeWrapper");
 const index_1 = require("../../../index");
 const kerror = __importStar(require("../../kerror"));
@@ -188,8 +189,7 @@ function execute(request, callback) {
         return bluebird_1.default.reject(error);
     }
     const promback = new promback_1.default(callback);
-    if (!request ||
-        (!(request instanceof index_1.KuzzleRequest) && !(request instanceof index_1.Request))) {
+    if (!request || lodash_1.default.isEmpty(request)) {
         return promback.reject(contextError.get("missing_request"));
     }
     if (request.input.controller === "realtime" &&

package/dist/lib/core/plugin/pluginManifest.d.ts

@@ -0,0 +1,5 @@
+export = PluginManifest;
+declare class PluginManifest extends AbstractManifest {
+    privileged: boolean;
+}
+import AbstractManifest = require("../shared/abstractManifest");

package/{lib → dist/lib}/core/plugin/pluginManifest.js

@@ -18,39 +18,28 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 "use strict";
-
 const _ = require("lodash");
-
 const kerror = require("../../kerror").wrap("plugin", "manifest");
 const AbstractManifest = require("../shared/abstractManifest");
-
 class PluginManifest extends AbstractManifest {
-  constructor(pluginPath) {
-    super(pluginPath);
-    this.privileged = false;
-  }
-
-  load() {
-    super.load();
-
-    // Ensure ES will accept the plugin name as index
-    if (!/^[\w-]+$/.test(this.name)) {
-      throw kerror.get("invalid_name", this.path);
+    constructor(pluginPath) {
+        super(pluginPath);
+        this.privileged = false;
     }
-
-    if (!_.isNil(this.raw) && !_.isNil(this.raw.privileged)) {
-      if (typeof this.raw.privileged !== "boolean") {
-        throw kerror.get(
-          "invalid_privileged",
-          this.path,
-          typeof this.raw.privileged,
-        );
-      }
-      this.privileged = this.raw.privileged;
+    load() {
+        super.load();
+        // Ensure ES will accept the plugin name as index
+        if (!/^[\w-]+$/.test(this.name)) {
+            throw kerror.get("invalid_name", this.path);
+        }
+        if (!_.isNil(this.raw) && !_.isNil(this.raw.privileged)) {
+            if (typeof this.raw.privileged !== "boolean") {
+                throw kerror.get("invalid_privileged", this.path, typeof this.raw.privileged);
+            }
+            this.privileged = this.raw.privileged;
+        }
     }
-  }
 }
-
 module.exports = PluginManifest;
+//# sourceMappingURL=pluginManifest.js.map

package/dist/lib/core/plugin/pluginRepository.d.ts

@@ -0,0 +1,53 @@
+export = PluginRepository;
+declare class PluginRepository extends ObjectRepository<any> {
+    constructor(store: any, collection: any);
+    collection: any;
+    ObjectConstructor: ObjectConstructor;
+    init(options: any): void;
+    /**
+     * Serializes the object before being persisted to database.
+     *
+     * @param {object} data - The object to serialize
+     * @returns {object}
+     */
+    serializeToDatabase(data: object): object;
+    /**
+     * @param {object} object
+     * @param {object} [options]
+     * @returns {Promise}
+     */
+    create(object: object, options?: object): Promise<any>;
+    /**
+     * @param {object} object
+     * @param {object} [options]
+     * @returns {Promise}
+     */
+    createOrReplace(object: object, options?: object): Promise<any>;
+    /**
+     * @param {object} object
+     * @param {object} [options]
+     * @returns {Promise}
+     */
+    replace(object: object, options?: object): Promise<any>;
+    /**
+     * @param {object} object
+     * @param {object} [options]
+     * @returns {Promise}
+     */
+    update(object: object, options?: object): Promise<any>;
+    /**
+     * If we load a user that does not exists, we have to resolve the promise with null
+     * instead of throwing NotFoundError
+     *
+     * @param {string} documentId
+     * @returns {Promise}
+     */
+    load(documentId: string): Promise<any>;
+    /**
+     * @param {string} documentId
+     * @param {object} [options]
+     * @returns {Promise}
+     */
+    delete(documentId: string, options?: object): Promise<any>;
+}
+import { ObjectRepository } from "../shared/ObjectRepository";