kuzzle 2.16.10 → 2.17.1

package/lib/kuzzle/event/waterfall.js

@@ -28,7 +28,7 @@ class WaterfallContext {
    * @param  {Function} cb     - end of waterfall callback
    * @param  {Object}   cbCtx  - functions context
    */
-  constructor(chain, args, cb, cbCtx) {
+  constructor (chain, args, cb, cbCtx) {
     this.chain = chain;
     this.cb = cb;
     this.cbCtx = cbCtx;
@@ -55,7 +55,7 @@ class WaterfallContext {
 
   next (cb) {
     this.index++;
-    this.chain[this.index-1](...this.args, cb);
+    this.chain[this.index - 1](...this.args, cb);
   }
 
   reject (error) {
@@ -69,7 +69,7 @@ class WaterfallContext {
 }
 
 /* eslint-disable no-invalid-this */
-function waterfallCB(err, res) {
+function waterfallCB (err, res) {
   if (err) {
     this.reject(err);
   }
@@ -80,8 +80,8 @@ function waterfallCB(err, res) {
 }
 /* eslint-enable no-invalid-this */
 
-function waterfallNext(ctx) {
-  if (!ctx.hasNext()) {
+function waterfallNext (ctx) {
+  if (! ctx.hasNext()) {
     ctx.resolve();
     return;
   }
@@ -94,7 +94,7 @@ function waterfallNext(ctx) {
   }
 }
 
-function waterfall(chain, args, cb, context) {
+function waterfall (chain, args, cb, context) {
   const ctx = new WaterfallContext(chain, args, cb, context);
 
   waterfallNext(ctx);

package/lib/kuzzle/kuzzle.js

@@ -19,6 +19,25 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 };
 };
@@ -45,7 +64,7 @@ const vault_1 = __importDefault(require("./vault"));
 const dumpGenerator_1 = __importDefault(require("./dumpGenerator"));
 const asyncStore_1 = __importDefault(require("../util/asyncStore"));
 const mutex_1 = require("../util/mutex");
-const kerror_1 = __importDefault(require("../kerror"));
+const kerror = __importStar(require("../kerror"));
 const internalIndexHandler_1 = __importDefault(require("./internalIndexHandler"));
 const cacheEngine_1 = __importDefault(require("../core/cache/cacheEngine"));
 const storageEngine_1 = __importDefault(require("../core/storage/storageEngine"));
@@ -53,6 +72,8 @@ const security_1 = __importDefault(require("../core/security"));
 const realtime_1 = __importDefault(require("../core/realtime"));
 const cluster_1 = __importDefault(require("../cluster"));
 const package_json_1 = require("../../package.json");
+const name_generator_1 = require("../util/name-generator");
+const openapi_1 = require("../api/openapi");
 const BACKEND_IMPORT_KEY = 'backend:init:import';
 let _kuzzle = null;
 Reflect.defineProperty(global, 'kuzzle', {
@@ -103,7 +124,7 @@ class Kuzzle extends kuzzleEventEmitter_1.default {
     /**
      * Initializes all the needed components of Kuzzle.
      *
-     * @param {Application} - Application instance
+     * @param {Application} - Application Plugin instance
      * @param {Object} - Additional options (import, installations, plugins, secretsFile, support, vaultKey)
      *
      * @this {Kuzzle}
@@ -124,7 +145,8 @@ class Kuzzle extends kuzzleEventEmitter_1.default {
             await (new realtime_1.default()).init();
             await this.internalIndex.init();
             await (new security_1.default()).init();
-            this.id = await (new cluster_1.default()).init();
+            // This will init the cluster module if enabled
+            this.id = await this.initKuzzleNode();
             // Secret used to generate JWTs
             this.secret = await this.internalIndex.getSecret();
             this.vault = vault_1.default.load(options.vaultKey, options.secretsFile);
@@ -141,11 +163,13 @@ class Kuzzle extends kuzzleEventEmitter_1.default {
             this.log.info(`[✔] Successfully loaded ${this.pluginsManager.loadedPlugins.length} plugins: ${this.pluginsManager.loadedPlugins.join(', ')}`);
             // Authentification plugins must be loaded before users import to avoid
             // credentials related error which would prevent Kuzzle from starting
-            await this.import(options.import, options.support);
+            await this.loadInitialState(options.import, options.support);
             await this.ask('core:security:verify');
             this.router.init();
             this.log.info('[✔] Core components loaded');
             await this.install(options.installations);
+            this.log.info(`[✔] Start "${this.pluginsManager.application.name}" application`);
+            this.openApiManager = new openapi_1.OpenApiManager(application.openApi, this.config.http.routes, this.pluginsManager.routes);
             // @deprecated
             await this.pipe('kuzzle:start');
             await this.pipe('kuzzle:state:live');
@@ -161,6 +185,23 @@ class Kuzzle extends kuzzleEventEmitter_1.default {
             throw error;
         }
     }
+    /**
+     * Generates the node ID.
+     *
+     * This will init the cluster if it's enabled.
+     */
+    async initKuzzleNode() {
+        let id;
+        if (this.config.cluster.enabled) {
+            id = await (new cluster_1.default()).init();
+            this.log.info('[✔] Cluster initialized');
+        }
+        else {
+            id = (0, name_generator_1.generateRandomName)('knode');
+            this.log.info('[X] Cluster disabled: single node mode.');
+        }
+        return id;
+    }
     /**
      * Gracefully exits after processing remaining requests
      *
@@ -202,7 +243,7 @@ class Kuzzle extends kuzzleEventEmitter_1.default {
                         await installation.handler();
                     }
                     catch (error) {
-                        throw kerror_1.default.get('plugin', 'runtime', 'unexpected_installation_error', installation.id, error);
+                        throw kerror.get('plugin', 'runtime', 'unexpected_installation_error', installation.id, error);
                     }
                     await this.ask('core:storage:private:document:create', 'kuzzle', 'installations', {
                         description: installation.description,
@@ -244,7 +285,7 @@ class Kuzzle extends kuzzleEventEmitter_1.default {
         const toImport = config.toImport;
         const toSupport = config.toSupport;
         if (!lodash_1.default.isEmpty(toSupport.mappings) && !lodash_1.default.isEmpty(toImport.mappings)) {
-            throw kerror_1.default.get('plugin', 'runtime', 'incompatible', '_support.mappings', 'import.mappings');
+            throw kerror.get('plugin', 'runtime', 'incompatible', '_support.mappings', 'import.mappings');
         }
         else if (!lodash_1.default.isEmpty(toSupport.mappings)) {
             await this.ask('core:storage:public:mappings:import', toSupport.mappings, {
@@ -296,7 +337,7 @@ class Kuzzle extends kuzzleEventEmitter_1.default {
                 && lodash_1.default.isEmpty(toSupport.securities.roles)
                 && lodash_1.default.isEmpty(toSupport.securities.users));
         if (isPermissionsToSupport && isPermissionsToImport) {
-            throw kerror_1.default.get('plugin', 'runtime', 'incompatible', '_support.securities', 'import profiles roles or users');
+            throw kerror.get('plugin', 'runtime', 'incompatible', '_support.securities', 'import profiles roles or users');
         }
         else if (isPermissionsToSupport) {
             await this.ask('core:security:load', toSupport.securities, {
@@ -340,7 +381,17 @@ class Kuzzle extends kuzzleEventEmitter_1.default {
      *
      * @returns {Promise<void>}
      */
-    async import(toImport = {}, toSupport = {}) {
+    async loadInitialState(toImport = {}, toSupport = {}) {
+        if (lodash_1.default.isEmpty(toImport.mappings)
+            && lodash_1.default.isEmpty(toImport.profiles)
+            && lodash_1.default.isEmpty(toImport.roles)
+            && lodash_1.default.isEmpty(toImport.userMappings)
+            && lodash_1.default.isEmpty(toImport.users)
+            && lodash_1.default.isEmpty(toSupport.fixtures)
+            && lodash_1.default.isEmpty(toSupport.mappings)
+            && lodash_1.default.isEmpty(toSupport.securities)) {
+            return;
+        }
         const lockedMutex = [];
         try {
             for (const [type, importMethod] of Object.entries(this.importTypes)) {
@@ -357,7 +408,6 @@ class Kuzzle extends kuzzleEventEmitter_1.default {
                     await this.ask('core:cache:internal:store', `${BACKEND_IMPORT_KEY}:${type}`, 1, { ttl: 5 * 60 * 1000 });
                 }
             }
-            this.log.info('[✔] Waiting for imports to be finished');
             await this._waitForImportToFinish();
             this.log.info('[✔] Import successful');
         }

package/lib/kuzzle/log.js

@@ -22,7 +22,7 @@
 'use strict';
 
 class Logger {
-  constructor() {
+  constructor () {
     this.logMethods = ['info', 'warn', 'error', 'silly', 'debug', 'verbose'];
 
     this.failsafeModeString = global.kuzzle.config.plugins.common.failsafeMode
@@ -34,7 +34,7 @@ class Logger {
     global.kuzzle.once('core:kuzzleStart', this._useLogger.bind(this));
   }
 
-  _useConsole() {
+  _useConsole () {
     // until kuzzle has started, use the console to print logs
     for (const method of this.logMethods) {
       this[method] = message => {
@@ -46,7 +46,7 @@ class Logger {
     }
   }
 
-  _useLogger() {
+  _useLogger () {
 
     // when kuzzle has started, use the event to dispatch logs
     for (const method of this.logMethods) {

package/lib/kuzzle/vault.js

@@ -38,7 +38,7 @@ function load (vaultKey, secretsFile) {
     secretsFile || process.env.KUZZLE_SECRETS_FILE || defaultEncryptedSecretsFile;
 
   let key = vaultKey;
-  if (_.isEmpty(vaultKey) && !_.isEmpty(process.env.KUZZLE_VAULT_KEY)) {
+  if (_.isEmpty(vaultKey) && ! _.isEmpty(process.env.KUZZLE_VAULT_KEY)) {
     key = process.env.KUZZLE_VAULT_KEY;
   }
 
@@ -53,13 +53,13 @@ function load (vaultKey, secretsFile) {
   // Abort if a secret file is found (default or custom)
   // but no vault key has been provided
   assert(
-    !(fileExists && _.isEmpty(key)),
+    ! (fileExists && _.isEmpty(key)),
     'A secret file has been provided but Kuzzle cannot find the Vault key. Aborting.');
 
   // Abort if a vault key has been provided
   // but no secrets file can be loaded (default or custom)
   assert(
-    !(! _.isEmpty(key) && ! fileExists),
+    ! (! _.isEmpty(key) && ! fileExists),
     `A Vault key is present but Kuzzle cannot find the secret file at "${encryptedSecretsFile}". Aborting.`);
 
   const vault = new Vault(key);

package/lib/model/security/profile.d.ts

@@ -0,0 +1,54 @@
+import { Policy, OptimizedPolicy, OptimizedPolicyRestrictions } from '../../types/index';
+import { Role } from './role';
+import { KuzzleRequest } from '../../../index';
+/** @internal */
+declare type InternalProfilePolicy = {
+    role: Role;
+    restrictedTo: OptimizedPolicyRestrictions;
+};
+/**
+ * @class Profile
+ */
+export declare class Profile {
+    _id: string;
+    policies: Policy[];
+    optimizedPolicies: OptimizedPolicy[];
+    rateLimit: number;
+    constructor();
+    /**
+     * @param {Kuzzle} kuzzle
+     *
+     * @returns {Promise}
+     */
+    getPolicies(): Promise<InternalProfilePolicy[]>;
+    /**
+     * @param {Request} request
+     * @returns {Promise}
+     */
+    getAllowedPolicies(request: KuzzleRequest): Promise<InternalProfilePolicy[]>;
+    /**
+     * @param {Request} request
+     * @returns {Promise<boolean>}
+     */
+    isActionAllowed(request: KuzzleRequest): Promise<boolean>;
+    /**
+     * Validates the Profile format
+     *
+     * @param {Object} [options]
+     * @param {boolean} [options.strict] - If true, only allows resctrictions on
+     *                                     existing indexes/collections
+     * @returns {Promise}
+     */
+    validateDefinition({ strict }?: {
+        strict?: boolean;
+    }): Promise<boolean>;
+    /**
+     * Resolves an array of rights related to the profile's roles.
+     *
+     * @returns {Promise}
+     */
+    getRights(): Promise<{}>;
+    static _hash(): boolean;
+    validateRateLimit(): void;
+}
+export {};