kuzzle 2.49.1 → 2.50.0-beta.4

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

@@ -0,0 +1,112 @@
+/*
+ * 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 { merge } = require("lodash");
+const { NotFoundError } = require("../../kerror/errors");
+const { ObjectRepository } = require("../shared/ObjectRepository");
+const { cacheDbEnum } = require("../cache/cacheDbEnum");
+class PluginRepository extends ObjectRepository {
+    constructor(store, collection) {
+        super({ cache: cacheDbEnum.NONE, store });
+        this.collection = collection;
+        this.ObjectConstructor = Object;
+    }
+    init(options) {
+        if (options && typeof options === "object" && !Array.isArray(options)) {
+            if (options.ObjectConstructor) {
+                this.ObjectConstructor = options.ObjectConstructor;
+            }
+        }
+    }
+    /**
+     * Serializes the object before being persisted to database.
+     *
+     * @param {object} data - The object to serialize
+     * @returns {object}
+     */
+    serializeToDatabase(data) {
+        // avoid the data var mutation
+        const result = merge({}, data);
+        delete result._id;
+        return result;
+    }
+    /**
+     * @param {object} object
+     * @param {object} [options]
+     * @returns {Promise}
+     */
+    create(object, options = {}) {
+        const opts = Object.assign({ method: "create" }, options);
+        return this.persistToDatabase(object, opts);
+    }
+    /**
+     * @param {object} object
+     * @param {object} [options]
+     * @returns {Promise}
+     */
+    createOrReplace(object, options = {}) {
+        const opts = Object.assign({ method: "createOrReplace" }, options);
+        return this.persistToDatabase(object, opts);
+    }
+    /**
+     * @param {object} object
+     * @param {object} [options]
+     * @returns {Promise}
+     */
+    replace(object, options = {}) {
+        const opts = Object.assign({ method: "replace" }, options);
+        return this.persistToDatabase(object, opts);
+    }
+    /**
+     * @param {object} object
+     * @param {object} [options]
+     * @returns {Promise}
+     */
+    update(object, options = {}) {
+        const opts = Object.assign({ method: "update" }, options);
+        return this.persistToDatabase(object, opts);
+    }
+    /**
+     * 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) {
+        return super.load(documentId).catch((error) => {
+            if (this.collection === "users" && error instanceof NotFoundError) {
+                return Promise.resolve(null);
+            }
+            throw error;
+        });
+    }
+    /**
+     * @param {string} documentId
+     * @param {object} [options]
+     * @returns {Promise}
+     */
+    delete(documentId, options = {}) {
+        return super.delete({ _id: documentId }, options);
+    }
+}
+module.exports = PluginRepository;
+//# sourceMappingURL=pluginRepository.js.map

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

@@ -0,0 +1,190 @@
+export = PluginsManager;
+/**
+ * @class PluginsManager
+ * @param {Kuzzle} kuzzle
+ */
+declare class PluginsManager {
+    _plugins: Map<any, any>;
+    controllers: Map<any, any>;
+    strategies: {};
+    routes: any[];
+    pluginsEnabledDir: string;
+    pluginsAvailableDir: string;
+    /**
+     * @example
+     * {
+     *   pluginName: {
+     *     authName: <constructor>,
+     *     authname2: <constructor>,
+     *     ...
+     *   },
+     *   pluginName2: {
+     *     ...
+     *   }
+     * }
+     *
+     * This structure prevents authenticator names collisions between
+     * multiple auth. plugins
+     */
+    authenticators: {};
+    config: import("../../..").PluginsConfiguration;
+    logger: import("../../kuzzle/Logger").Logger;
+    loadedPlugins: any[];
+    set application(plugin: any);
+    get application(): any;
+    get plugins(): any[];
+    /**
+     * Giving a controller name, tells if exists
+     *
+     * @param {string} controller
+     * @returns {Boolean}
+     */
+    isController(controller: string): boolean;
+    /**
+     * Giving a controller name and an action, tells if action exists
+     *
+     * @param {string} controller
+     * @param {string} action
+     * @returns {Boolean}
+     */
+    isAction(controller: string, action: string): boolean;
+    /**
+     * Giving a controller name, returns its actions
+     *
+     * @param {string} controller
+     * @returns {Array}
+     */
+    getActions(controller: string): any[];
+    /**
+     * Returns an array filled with controller names
+     *
+     * @returns {Array}
+     */
+    getControllerNames(): any[];
+    /**
+     * Giving a plugin name, tell if it exists
+     *
+     * @param {string} pluginName
+     * @returns {boolean}
+     */
+    exists(pluginName: string): boolean;
+    /**
+     * Used to dump loaded plugin feature into serverInfo route / cli
+     *
+     * @returns {object}
+     */
+    getPluginsDescription(): object;
+    /**
+     * Register plugins feature to Kuzzle
+     *
+     * @returns {Promise}
+     *
+     * @throws PluginImplementationError - Throws when an error occurs when registering a plugin
+     */
+    init(plugins?: {}): Promise<any>;
+    /**
+     * @param {string} strategyName
+     * @returns {string[]}
+     */
+    getStrategyFields(strategyName: string): string[];
+    /**
+     * @param {string} strategyName
+     * @param {string} methodName
+     * @returns {boolean}
+     */
+    hasStrategyMethod(strategyName: string, methodName: string): boolean;
+    /**
+     * @param {string} strategyName
+     * @param {string} methodName
+     * @returns {function}
+     */
+    getStrategyMethod(strategyName: string, methodName: string): Function;
+    /**
+     * Returns the list of registered passport strategies
+     * @returns {string[]}
+     */
+    listStrategies(): string[];
+    /**
+     * Checks if a strategy is well-formed
+     *
+     * @param {string} pluginName
+     * @param {string} strategyName
+     * @param {object} strategy
+     * @throws {PluginImplementationError} If the strategy is invalid
+     */
+    validateStrategy(pluginName: string, strategyName: string, strategy: object): void;
+    /**
+     * Register a pipe function on an event
+     *
+     * @param {object} plugin
+     * @param {number} warnDelay - delay before a warning is issued
+     * @param {string} event name
+     * @param {Function} handler - function to attach
+     *
+     * @returns {string} pipeId
+     */
+    registerPipe(plugin: object, event: string, handler: Function): string;
+    unregisterPipe(pipeId: any): void;
+    /**
+     * Registers an authentication strategy.
+     * If the plugin init method has not been called yet, add the strategy to
+     * the plugin.instance.strategies object.
+     *
+     * @param {string} pluginName - plugin name
+     * @param {string} strategyName - strategy name
+     * @param {object} strategy - strategy properties
+     * @throws {PluginImplementationError} If the strategy is invalid or if
+     *                                     registration fails
+     */
+    registerStrategy(pluginName: string, strategyName: string, strategy: object): void;
+    /**
+     * Unregister
+     * @param {string} pluginName
+     * @param  {string} strategyName
+     * @throws {PluginImplementationError} If not the owner of the strategy or if strategy
+     *                                     does not exist
+     */
+    unregisterStrategy(pluginName: string, strategyName: string): void;
+    /**
+     * @param {object} plugin
+     * @param {number} pipeWarnTime
+     */
+    _initPipes(plugin: object): void;
+    /**
+     * @param {object} plugin
+     */
+    _initHooks(plugin: object): void;
+    _initApi(plugin: any): Promise<void>;
+    /**
+     * Init plugin controllers
+     *
+     * @param {object} plugin
+     * @returns {boolean}
+     */
+    _initControllers(plugin: object): boolean;
+    /**
+     * @param {object} plugin
+     * @throws {PluginImplementationError} If strategies registration fails
+     */
+    _initStrategies(plugin: object): void;
+    /**
+     * @param {object} plugin
+     * @throws {PluginImplementationError} If strategies registration fails
+     */
+    _initAuthenticators(plugin: object): void;
+    /**
+     * Load detected plugins in memory
+     *
+     * @returns {object} list of loaded plugin
+     */
+    loadPlugins(plugins?: {}): object;
+    /**
+     * Wraps a strategy plugin's verify function.
+     *
+     * @param {String} pluginName
+     * @param {String} strategyName
+     * @param {Function} verifyMethod - Strategy plugin's verify method
+     * @returns {Function}
+     */
+    wrapStrategyVerify(pluginName: string, strategyName: string, verifyMethod: Function): Function;
+}