kuzzle 2.16.11 → 2.17.0

package/lib/core/plugin/pluginRepository.js

@@ -36,7 +36,7 @@ class PluginRepository extends Repository {
   }
 
   init (options) {
-    if (options && typeof options === 'object' && !Array.isArray(options)) {
+    if (options && typeof options === 'object' && ! Array.isArray(options)) {
       if (options.ObjectConstructor) {
         this.ObjectConstructor = options.ObjectConstructor;
       }
@@ -64,7 +64,7 @@ class PluginRepository extends Repository {
    * @returns {Promise}
    */
   create (object, options = {}) {
-    const opts = Object.assign({method: 'create'}, options);
+    const opts = Object.assign({ method: 'create' }, options);
 
     return this.persistToDatabase(object, opts);
   }
@@ -75,7 +75,7 @@ class PluginRepository extends Repository {
    * @returns {Promise}
    */
   createOrReplace (object, options = {}) {
-    const opts = Object.assign({method: 'createOrReplace'}, options);
+    const opts = Object.assign({ method: 'createOrReplace' }, options);
 
     return this.persistToDatabase(object, opts);
   }
@@ -86,7 +86,7 @@ class PluginRepository extends Repository {
    * @returns {Promise}
    */
   replace (object, options = {}) {
-    const opts = Object.assign({method: 'replace'}, options);
+    const opts = Object.assign({ method: 'replace' }, options);
 
     return this.persistToDatabase(object, opts);
   }
@@ -97,7 +97,7 @@ class PluginRepository extends Repository {
    * @returns {Promise}
    */
   update (object, options = {}) {
-    const opts = Object.assign({method: 'update'}, options);
+    const opts = Object.assign({ method: 'update' }, options);
 
     return this.persistToDatabase(object, opts);
   }

package/lib/core/plugin/pluginsManager.js

@@ -50,7 +50,7 @@ const CORE_PLUGINS = ['kuzzle-plugin-logger', 'kuzzle-plugin-auth-passport-local
  * @param {Kuzzle} kuzzle
  */
 class PluginsManager {
-  constructor() {
+  constructor () {
     Reflect.defineProperty(this, 'kuzzle', {
       value: global.kuzzle,
     });
@@ -234,8 +234,7 @@ class PluginsManager {
           plugin.initCalled = true;
 
           if ( ! _.isEmpty(plugin.instance.controllers)
-            && ! _.isEmpty(plugin.instance.api))
-          {
+            && ! _.isEmpty(plugin.instance.api)) {
             throw assertionError.get('duplicated_api_definition');
           }
 
@@ -265,7 +264,9 @@ class PluginsManager {
 
           debug('[%s] plugin started', plugin.name);
 
-          this.loadedPlugins.push(plugin.name);
+          if (! plugin.application) {
+            this.loadedPlugins.push(plugin.name);
+          }
 
           return null;
         });
@@ -322,11 +323,11 @@ class PluginsManager {
   validateStrategy (pluginName, strategyName, strategy) {
     const errorPrefix = `[${pluginName}] Strategy ${strategyName}:`;
 
-    if (!isPlainObject(strategy)) {
+    if (! isPlainObject(strategy)) {
       throw strategyError.get('invalid_description', errorPrefix, strategy);
     }
 
-    if (!isPlainObject(strategy.methods)) {
+    if (! isPlainObject(strategy.methods)) {
       throw strategyError.get('invalid_methods', errorPrefix, strategy.methods);
     }
 
@@ -334,7 +335,7 @@ class PluginsManager {
 
     // required methods check
     ['exists', 'create', 'update', 'delete', 'validate', 'verify'].forEach(methodName => {
-      if (!_.isString(strategy.methods[methodName])) {
+      if (! _.isString(strategy.methods[methodName])) {
         throw strategyError.get(
           'invalid_method_type',
           errorPrefix,
@@ -342,7 +343,7 @@ class PluginsManager {
           strategy.methods[methodName]);
       }
 
-      if (!_.isFunction(plugin.instance[strategy.methods[methodName]])) {
+      if (! _.isFunction(plugin.instance[strategy.methods[methodName]])) {
         throw strategyError.get(
           'missing_method_function',
           errorPrefix,
@@ -354,8 +355,8 @@ class PluginsManager {
     ['getInfo', 'getById', 'afterRegister'].forEach(name => {
       const optionalMethodName = strategy.methods[name];
 
-      if (!_.isNil(optionalMethodName)) {
-        if (!_.isString(optionalMethodName)) {
+      if (! _.isNil(optionalMethodName)) {
+        if (! _.isString(optionalMethodName)) {
           throw strategyError.get(
             'invalid_method_type',
             errorPrefix,
@@ -363,7 +364,7 @@ class PluginsManager {
             optionalMethodName);
         }
 
-        if (!_.isFunction(plugin.instance[optionalMethodName])) {
+        if (! _.isFunction(plugin.instance[optionalMethodName])) {
           throw strategyError.get(
             'missing_method_function',
             errorPrefix,
@@ -372,7 +373,7 @@ class PluginsManager {
       }
     });
 
-    if (!isPlainObject(strategy.config)) {
+    if (! isPlainObject(strategy.config)) {
       throw strategyError.get('invalid_config', errorPrefix, strategy.config);
     }
 
@@ -382,8 +383,8 @@ class PluginsManager {
         errorPrefix,
         strategy.config.authenticator);
     }
-    else if (!this.authenticators[pluginName]
-      || !this.authenticators[pluginName][strategy.config.authenticator]
+    else if (! this.authenticators[pluginName]
+      || ! this.authenticators[pluginName][strategy.config.authenticator]
     ) {
       throw strategyError.get(
         'unknown_authenticator',
@@ -394,12 +395,12 @@ class PluginsManager {
     for (const optionName of ['strategyOptions', 'authenticateOptions']) {
       const options = strategy.config[optionName];
 
-      if (!_.isNil(options) && !isPlainObject(options)) {
+      if (! _.isNil(options) && ! isPlainObject(options)) {
         throw strategyError.get('invalid_option', errorPrefix, optionName, options);
       }
     }
 
-    if (!_.isNil(strategy.config.fields) && !Array.isArray(strategy.config.fields)) {
+    if (! _.isNil(strategy.config.fields) && ! Array.isArray(strategy.config.fields)) {
       throw strategyError.get('invalid_fields', errorPrefix, strategy.config.fields);
     }
   }
@@ -678,7 +679,7 @@ class PluginsManager {
           'Native controllers cannot be overriden');
       }
 
-      await Plugin.checkControllerDefinition(controller, definition);
+      Plugin.checkControllerDefinition(controller, definition);
 
       for (const [action, actionDefinition ] of Object.entries(definition.actions)) {
         let apiController = this.controllers.get(controller);
@@ -741,7 +742,7 @@ class PluginsManager {
    */
   _initControllers (plugin) {
     // @deprecated - warn about using the obsolete "controllers" object
-    if (!_.isEmpty(plugin.instance.controllers)) {
+    if (! _.isEmpty(plugin.instance.controllers)) {
       plugin.printDeprecation('Defining controllers using the "controllers" object is deprecated. You should use the "api" object instead.');
     }
 
@@ -756,7 +757,7 @@ class PluginsManager {
       const definition = plugin.instance.controllers[controller];
       const errorControllerPrefix = `Unable to inject controller "${controller}" from plugin "${plugin.name}":`;
 
-      if (!isPlainObject(definition)) {
+      if (! isPlainObject(definition)) {
         // @todo deprecate all those errors and use plugin.assert.invalid_controller_definition
         throw controllerError.get(
           'invalid_description',
@@ -809,7 +810,7 @@ class PluginsManager {
     const controllerNames = Object.keys(plugin.instance.controllers);
 
     // @deprecated - warn about using the obsolete "routes" object
-    if (!_.isEmpty(plugin.instance.routes)) {
+    if (! _.isEmpty(plugin.instance.routes)) {
       plugin.printDeprecation('Defining routes using the "routes" object is deprecated. You should use the "api" object instead.');
     }
 
@@ -835,7 +836,7 @@ class PluginsManager {
 
       const apiController = this.controllers.get(controller);
 
-      if (!apiController) {
+      if (! apiController) {
         throw controllerError.get(
           'undefined_controller',
           errorRoutePrefix,
@@ -843,7 +844,7 @@ class PluginsManager {
           didYouMean(route.controller, controllerNames));
       }
 
-      if (!apiController._isAction(route.action)) {
+      if (! apiController._isAction(route.action)) {
         const actionNames = Array.from(apiController._actions);
         throw controllerError.get(
           'undefined_action',
@@ -898,7 +899,7 @@ class PluginsManager {
    * @throws {PluginImplementationError} If strategies registration fails
    */
   _initStrategies (plugin) {
-    if ( !isPlainObject(plugin.instance.strategies)
+    if ( ! isPlainObject(plugin.instance.strategies)
       || _.isEmpty(plugin.instance.strategies)
     ) {
       throw strategyError.get('invalid_definition', plugin.logPrefix);
@@ -917,12 +918,12 @@ class PluginsManager {
    * @throws {PluginImplementationError} If strategies registration fails
    */
   _initAuthenticators (plugin) {
-    if (!isPlainObject(plugin.instance.authenticators)) {
+    if (! isPlainObject(plugin.instance.authenticators)) {
       throw kerror.get('plugin', 'authenticators', 'not_an_object', plugin.logPrefix);
     }
 
     for (const authenticator of Object.keys(plugin.instance.authenticators)) {
-      if (!isConstructor(plugin.instance.authenticators[authenticator])) {
+      if (! isConstructor(plugin.instance.authenticators[authenticator])) {
         throw kerror.get(
           'plugin',
           'authenticators',
@@ -1015,7 +1016,7 @@ class PluginsManager {
 
       // catching plugins returning non-thenable content
       // @todo - with async/await we might consider allowing non-promise results
-      if (!ret || !_.isFunction(ret.then)) {
+      if (! ret || ! _.isFunction(ret.then)) {
         callback(strategyError.get('invalid_verify_return', prefix, ret));
         return;
       }
@@ -1031,11 +1032,11 @@ class PluginsManager {
       }
 
       if (result === false) {
-        callback(null, result, {message: null});
+        callback(null, result, { message: null });
         return;
       }
 
-      if (!isPlainObject(result)) {
+      if (! isPlainObject(result)) {
         callback(strategyError.get('invalid_verify_resolve', prefix));
         return;
       }

package/lib/core/realtime/notification/server.js

@@ -30,7 +30,7 @@
  * @param {string} message - Notification message
  */
 class ServerNotification {
-  constructor(type, message) {
+  constructor (type, message) {
     this.status = 200;
     this.info = 'This is an automated server notification';
     this.message = message;

package/lib/core/realtime/notification/user.js

@@ -27,7 +27,7 @@
  * @class UserNotification
  */
 class UserNotification {
-  constructor(opts) {
+  constructor (opts) {
     this.type = 'user';
 
     this.status = opts.status;

package/lib/core/realtime/notifier.js

@@ -53,7 +53,7 @@ const KUZZLE_NOTIFICATION_CHANNEL = 'kuzzle:notification:server';
  * @class NotifierController
  */
 class NotifierController {
-  constructor(realtimeModule) {
+  constructor (realtimeModule) {
     this.module = realtimeModule;
     this.ttl = global.kuzzle.config.limits.subscriptionDocumentTTL;
   }
@@ -267,7 +267,7 @@ class NotifierController {
     let cached = action === actionEnum.REPLACE || action === actionEnum.UPDATE;
 
     const cacheIds = documents.map(doc => {
-      if ((action === actionEnum.WRITE || action === actionEnum.UPSERT) && !cached) {
+      if ((action === actionEnum.WRITE || action === actionEnum.UPSERT) && ! cached) {
         cached = doc.created !== true; // force a bool value if undefined
       }
 
@@ -414,7 +414,7 @@ class NotifierController {
    *
    * @returns {Promise}
    */
-  _notifyDocument (rooms, notification, { fromCluster=true } = {}) {
+  _notifyDocument (rooms, notification, { fromCluster = true } = {}) {
     const channels = [];
 
     for (const room of rooms) {
@@ -452,7 +452,7 @@ class NotifierController {
    *
    * @returns {Promise}
    */
-  _notifyUser (room, notification, { fromCluster=true } = {}) {
+  _notifyUser (room, notification, { fromCluster = true } = {}) {
     const channels = [];
     const hotelClerkRoom = this.module.hotelClerk.rooms.get(room);
 
@@ -493,7 +493,7 @@ class NotifierController {
   }
 }
 
-function getCachePrefix(request) {
+function getCachePrefix (request) {
   // use redis key hash tag
   // (see https://redis.io/topics/cluster-spec#keys-distribution-model)
   return `{notif/${request.input.args.index}/${request.input.args.collection}}/`;

package/lib/core/security/index.js

@@ -22,7 +22,7 @@
 'use strict';
 
 const RoleRepository = require('./roleRepository');
-const ProfileRepository = require('./profileRepository');
+const { ProfileRepository } = require('./profileRepository');
 const TokenRepository = require('./tokenRepository');
 const UserRepository = require('./userRepository');
 const SecurityLoader = require('./securityLoader');

package/lib/core/security/profileRepository.d.ts

@@ -0,0 +1,176 @@
+/// <reference types="lodash" />
+import { Profile } from '../../model/security/profile';
+import Repository from '../shared/repository';
+import { JSONObject } from 'kuzzle-sdk';
+/** @internal */
+declare type CreateOrReplaceOptions = {
+    method?: string;
+    refresh?: string;
+    strict?: boolean;
+    userId?: string;
+};
+/** @internal */
+declare type ValidateAndSaveProfileOptions = {
+    method?: string;
+    refresh?: string;
+    strict?: boolean;
+    retryOnConflict?: number;
+};
+/** @internal */
+declare type UpdateOptions = {
+    userId?: string;
+    refresh?: string;
+    strict?: boolean;
+    retryOnConflict?: number;
+};
+/**
+ * @class ProfileRepository
+ * @extends Repository
+ */
+export declare class ProfileRepository extends Repository {
+    private module;
+    private profiles;
+    /**
+     * @constructor
+     */
+    constructor(securityModule: any);
+    init(): void;
+    /**
+     * Loads a Profile
+     *
+     * @param {string} id
+     * @returns {Promise.<Promise>}
+     * @throws {NotFoundError} If the corresponding profile doesn't exist
+     */
+    load(id: string): Promise<Profile>;
+    /**
+     * Loads a Profile object given its id.
+     * Stores the promise of the profile being loaded in the memcache
+     * and then replaces it by the profile itself once it has been loaded
+     *
+     * This is to allow parallelisation while preventing sending requests
+     * to ES, which is slow
+     *
+     * @param {Array} profileIds - Array of profiles ids
+     * @param {Object} options - resetCache (false)
+     *
+     * @returns {Promise} Resolves to the matching Profile object if found, null
+     * if not.
+     */
+    loadProfiles(profileIds?: string[]): Promise<Profile[]>;
+    /**
+     * @override
+     */
+    loadOneFromDatabase(id: string): Promise<Profile>;
+    /**
+     * Creates a new profile, or create/replace a profile
+     *
+     * @param {String} id
+     * @param {Object} policies
+     * @param {Object} [opts]
+     * @returns {Profile}
+     */
+    _createOrReplace(id: string, content: JSONObject, { method, refresh, strict, userId }?: CreateOrReplaceOptions): Promise<Profile>;
+    /**
+     * Creates a new profile
+     *
+     * @param {String} id
+     * @param {Object} content
+     * @param {Object} [opts]
+     * @returns {Profile}
+     */
+    create(id: string, content: JSONObject, opts?: JSONObject): Promise<Profile>;
+    /**
+     * Creates or replaces a profile
+     *
+     * @param {String} id
+     * @param {Object} content
+     * @param {Object} [opts]
+     * @returns {Profile}
+     */
+    createOrReplace(id: string, content: JSONObject, opts?: JSONObject): Promise<Profile>;
+    /**
+     * Updates a profile
+     * @param  {String} id
+     * @param  {Object} content
+     * @param  {Object} [opts]
+     * @returns {Promise}
+     */
+    update(id: string, content: JSONObject, { refresh, retryOnConflict, strict, userId }?: UpdateOptions): Promise<Profile>;
+    /**
+     * Deletes a profile
+     *
+     * @param {String} id
+     * @param {object} [options]
+     * @returns {Promise}
+     */
+    deleteById(id: string, options?: JSONObject): Promise<void>;
+    /**
+     * @override
+     */
+    delete(profile: Profile, { refresh, onAssignedUsers, userId, }?: {
+        refresh?: string;
+        onAssignedUsers?: string;
+        userId?: string;
+    }): Promise<void>;
+    /**
+     * From a Profile object, returns a serialized object ready to be persisted
+     * to the database.
+     *
+     * @param {Profile} profile
+     * @returns {object}
+     */
+    serializeToDatabase(profile: Profile): import("lodash").Omit<Profile, "_id">;
+    /**
+     * Given a Profile object, validates its definition and if OK, persist it to the database.
+     *
+     * @param {Profile} profile
+     * @param {Object} [options]
+     * @param {string} [options.method] - Document persistence method
+     * @param {string} [options.refresh] - (Don't) wait for index refresh
+     * @param {number} [options.retryOnConflict] - Number of retries when an
+     *                                             update fails due to a conflict
+     * @param {boolean} [options.strict] - if true, restrictions can only be
+     *                                     applied on existing indexes/collections
+     * @returns {Promise<Profile>}
+     **/
+    validateAndSaveProfile(profile: Profile, { method, refresh, retryOnConflict, strict }?: ValidateAndSaveProfileOptions): Promise<Profile>;
+    /**
+     * @param {object} dto
+     * @returns {Promise<Profile>}
+     */
+    fromDTO(dto: JSONObject): Promise<Profile>;
+    /**
+     * @override
+     */
+    truncate(opts: JSONObject): Promise<void>;
+    /**
+     * Invalidate the cache entries for the given profile. If none is provided,
+     * the entire cache is emptied.
+     * @param {string} [profileId]
+     */
+    invalidate(profileId?: string): void;
+    /**
+     * Optimize each policy to get a O(1) index access time
+     * and a O(log(n)) collection search time.
+     *
+     * - Deduplicate indexes using a map
+     * - Sort collections per index
+     * @param {Object[]} policies
+     */
+    private optimizePolicies;
+    /**
+     * Optimize a policy to get a O(1) index access time
+     * and a O(log(n)) collection search time.
+     *
+     * - Deduplicate indexes using a map
+     * - Sort collections per index
+     * @param policy
+     */
+    private optimizePolicy;
+    toDTO(dto: Profile): Promise<JSONObject>;
+    deleteFromDatabase(id: string, options: JSONObject): Promise<any>;
+    search(searchBody: JSONObject, options: JSONObject): Promise<any>;
+    scroll(id: string, ttl: number): Promise<any>;
+}
+export {};