kuzzle 2.17.8 → 2.19.0

package/index.d.ts

@@ -6,5 +6,6 @@ export * from './lib/api/request';
 export * from './lib/kerror/errors';
 export * from './lib/util/mutex';
 export * from './lib/util/inflector';
+export { NameGenerator } from './lib/util/name-generator';
 export * from 'kuzzle-sdk';
 export * from './lib/core/shared/KoncordeWrapper';

package/index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.NameGenerator = void 0;
 __exportStar(require("./lib/core/backend"), exports);
 __exportStar(require("./lib/types"), exports);
 __exportStar(require("./lib/core/plugin/pluginContext"), exports);
@@ -22,6 +23,8 @@ __exportStar(require("./lib/api/request"), exports);
 __exportStar(require("./lib/kerror/errors"), exports);
 __exportStar(require("./lib/util/mutex"), exports);
 __exportStar(require("./lib/util/inflector"), exports);
+var name_generator_1 = require("./lib/util/name-generator");
+Object.defineProperty(exports, "NameGenerator", { enumerable: true, get: function () { return name_generator_1.NameGenerator; } });
 __exportStar(require("kuzzle-sdk"), exports);
 __exportStar(require("./lib/core/shared/KoncordeWrapper"), exports);
 //# sourceMappingURL=index.js.map

package/lib/api/controllers/adminController.js

@@ -26,6 +26,7 @@ const Bluebird = require('bluebird');
 const kerror = require('../../kerror');
 const { NativeController } = require('./baseController');
 const { Mutex } = require('../../util/mutex');
+const { BACKEND_IMPORT_KEY } = require('../../kuzzle/kuzzle');
 
 /**
  * @class AdminController
@@ -97,6 +98,10 @@ class AdminController extends NativeController {
         options);
 
       await global.kuzzle.internalIndex.createInitialSecurities();
+
+      await this.ask(
+        'core:cache:internal:del',
+        `${BACKEND_IMPORT_KEY}:permissions`);
     }
     finally {
       await mutex.unlock();
@@ -119,6 +124,10 @@ class AdminController extends NativeController {
       const indexes = await this.ask('core:storage:public:index:list');
       await this.ask('core:storage:public:index:mDelete', indexes);
 
+      await this.ask(
+        'core:cache:internal:del',
+        `${BACKEND_IMPORT_KEY}:mappings`);
+
       return { acknowledge: true };
     }
     finally {

package/lib/api/controllers/authController.js

@@ -35,6 +35,7 @@ const { NativeController } = require('./baseController');
 const formatProcessing = require('../../core/auth/formatProcessing');
 const { User } = require('../../model/security/user');
 const ApiKey = require('../../model/storage/apiKey');
+const SecurityController = require('./securityController');
 
 /**
  * @class AuthController
@@ -471,7 +472,7 @@ class AuthController extends NativeController {
         userId,
       });
 
-    global.kuzzle.log.info(`[SECURITY] User "${userId}" applied action "${request.input.action}" on user "${userId}."`);
+    global.kuzzle.log.info(`[SECURITY] ${SecurityController.userOrSdk(userId)} applied action "${request.input.action}" on user "${userId}."`);
 
     return formatProcessing.serializeUser(user);
   }
@@ -646,7 +647,12 @@ class AuthController extends NativeController {
 
   assertIsAuthenticated (request) {
     if (request.context.user._id === this.anonymousId) {
-      throw kerror.get('security', 'rights', 'unauthorized');
+      throw kerror.get(
+        'security',
+        'rights',
+        'unauthorized',
+        request.input.controller,
+        request.input.action);
     }
   }
 }

package/lib/api/controllers/debugController.d.ts

@@ -0,0 +1,59 @@
+import { KuzzleRequest } from '../request';
+import { NativeController } from './baseController';
+/**
+ * @class DebugController
+ */
+export declare class DebugController extends NativeController {
+    private inspector;
+    private debuggerStatus;
+    /**
+     * Map<eventName, Set<connectionId>>
+     */
+    private events;
+    /**
+     * Map of functions from the DebugModules
+     */
+    private kuzzlePostMethods;
+    /**
+     * List of DebugModule for DebugController
+     * Used to add new methods and events to the protocol
+     */
+    private modules;
+    constructor();
+    init(): Promise<void>;
+    nodeVersion(): Promise<string>;
+    /**
+     * Connect the debugger
+     */
+    enable(): Promise<void>;
+    /**
+     * Disconnect the debugger and clears all the events listeners
+     */
+    disable(): Promise<void>;
+    /**
+     * Trigger action from debugger directly following the Chrome Debug Protocol
+     * See: https://chromedevtools.github.io/devtools-protocol/v8/
+     */
+    post(request: KuzzleRequest): Promise<any>;
+    /**
+     * Make the websocket connection listen and receive events from Chrome Debug Protocol
+     * See events from: https://chromedevtools.github.io/devtools-protocol/v8/
+     */
+    addListener(request: KuzzleRequest): Promise<void>;
+    /**
+     * Remove the websocket connection from the events' listeners
+     */
+    removeListener(request: KuzzleRequest): Promise<void>;
+    /**
+     * Execute a method using the Chrome Debug Protocol
+     * @param method Chrome Debug Protocol method to execute
+     * @param params
+     * @returns
+     */
+    private inspectorPost;
+    /**
+     * Sends a direct notification to a websocket connection without having to listen to a specific room
+     */
+    private notifyConnection;
+    private notifyGlobalListeners;
+}

package/lib/api/controllers/debugController.js

@@ -0,0 +1,285 @@
+"use strict";
+/*
+ * 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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DebugController = void 0;
+const baseController_1 = require("./baseController");
+const inspector_1 = __importDefault(require("inspector"));
+const kerror = __importStar(require("../../kerror"));
+const get_1 = __importDefault(require("lodash/get"));
+const DEBUGGER_EVENT = 'kuzzle-debugger-event';
+/**
+ * @class DebugController
+ */
+class DebugController extends baseController_1.NativeController {
+    constructor() {
+        super([
+            'nodeVersion',
+            'enable',
+            'disable',
+            'post',
+            'addListener',
+            'removeListener',
+        ]);
+        this.debuggerStatus = false;
+        /**
+         * Map<eventName, Set<connectionId>>
+         */
+        this.events = new Map();
+        /**
+         * Map of functions from the DebugModules
+         */
+        this.kuzzlePostMethods = new Map();
+        /**
+         * List of DebugModule for DebugController
+         * Used to add new methods and events to the protocol
+         */
+        this.modules = [];
+    }
+    async init() {
+        super.init();
+        this.inspector = new inspector_1.default.Session();
+        // Remove connection id from the list of listeners for each event
+        global.kuzzle.on('connection:remove', connectionId => {
+            if (!this.debuggerStatus) {
+                return;
+            }
+            for (const listener of this.events.values()) {
+                listener.delete(connectionId);
+            }
+        });
+        this.inspector.on('inspectorNotification', async (payload) => {
+            if (!this.debuggerStatus) {
+                return;
+            }
+            await this.notifyGlobalListeners(payload.method, payload);
+            const listeners = this.events.get(payload.method);
+            if (!listeners) {
+                return;
+            }
+            const promises = [];
+            for (const connectionId of listeners) {
+                promises.push(this.notifyConnection(connectionId, DEBUGGER_EVENT, {
+                    event: payload.method,
+                    result: payload
+                }));
+            }
+            // No need to catch, notify is already try-catched
+            await Promise.all(promises);
+        });
+    }
+    async nodeVersion() {
+        return process.version;
+    }
+    /**
+     * Connect the debugger
+     */
+    async enable() {
+        if (this.debuggerStatus) {
+            return;
+        }
+        this.inspector.connect();
+        this.debuggerStatus = true;
+        for (const module of this.modules) {
+            await module.init(this.inspector);
+            for (const methodName of module.methods) {
+                if (!module[methodName]) {
+                    throw new Error(`Missing implementation of method "${methodName}" inside DebugModule "${module.name}"`);
+                }
+                this.kuzzlePostMethods.set(`Kuzzle.${module.name}.${methodName}`, module[methodName].bind(module));
+            }
+            for (const eventName of module.events) {
+                module.on(eventName, async (payload) => {
+                    if (!this.debuggerStatus) {
+                        return;
+                    }
+                    const event = `Kuzzle.${module.name}.${eventName}`;
+                    await this.notifyGlobalListeners(event, payload);
+                    const listeners = this.events.get(event);
+                    if (!listeners) {
+                        return;
+                    }
+                    const promises = [];
+                    for (const connectionId of listeners) {
+                        promises.push(this.notifyConnection(connectionId, DEBUGGER_EVENT, {
+                            event,
+                            result: payload
+                        }));
+                    }
+                    // No need to catch, notify is already try-catched
+                    await Promise.all(promises);
+                });
+            }
+        }
+    }
+    /**
+     * Disconnect the debugger and clears all the events listeners
+     */
+    async disable() {
+        if (!this.debuggerStatus) {
+            return;
+        }
+        for (const module of this.modules) {
+            for (const eventName of module.events) {
+                module.removeAllListeners(eventName);
+            }
+            await module.cleanup();
+        }
+        this.inspector.disconnect();
+        this.debuggerStatus = false;
+        this.events.clear();
+        this.kuzzlePostMethods.clear();
+    }
+    /**
+     * Trigger action from debugger directly following the Chrome Debug Protocol
+     * See: https://chromedevtools.github.io/devtools-protocol/v8/
+     */
+    async post(request) {
+        if (!this.debuggerStatus) {
+            throw kerror.get('core', 'debugger', 'not_enabled');
+        }
+        const method = request.getBodyString('method');
+        const params = request.getBodyObject('params', {});
+        if (method.startsWith('Kuzzle.')) {
+            const debugModuleMethod = this.kuzzlePostMethods.get(method);
+            if (debugModuleMethod) {
+                return debugModuleMethod(params);
+            }
+            throw kerror.get('core', 'debugger', 'method_not_found', method);
+        }
+        if (!(0, get_1.default)(global.kuzzle.config, 'security.debug.native_debug_protocol')) {
+            throw kerror.get('core', 'debugger', 'native_debug_protocol_usage_denied');
+        }
+        return this.inspectorPost(method, params);
+    }
+    /**
+     * Make the websocket connection listen and receive events from Chrome Debug Protocol
+     * See events from: https://chromedevtools.github.io/devtools-protocol/v8/
+     */
+    async addListener(request) {
+        if (request.context.connection.protocol !== 'websocket') {
+            throw kerror.get('api', 'assert', 'unsupported_protocol', request.context.connection.protocol, 'debug:addListener');
+        }
+        if (!this.debuggerStatus) {
+            throw kerror.get('core', 'debugger', 'not_enabled');
+        }
+        const event = request.getBodyString('event');
+        let listeners = this.events.get(event);
+        if (!listeners) {
+            listeners = new Set();
+            this.events.set(event, listeners);
+        }
+        listeners.add(request.context.connection.id);
+    }
+    /**
+     * Remove the websocket connection from the events' listeners
+     */
+    async removeListener(request) {
+        if (request.context.connection.protocol !== 'websocket') {
+            throw kerror.get('api', 'assert', 'unsupported_protocol', request.context.connection.protocol, 'debug:removeListener');
+        }
+        if (!this.debuggerStatus) {
+            throw kerror.get('core', 'debugger', 'not_enabled');
+        }
+        const event = request.getBodyString('event');
+        const listeners = this.events.get(event);
+        if (listeners) {
+            listeners.delete(request.context.connection.id);
+        }
+    }
+    /**
+     * Execute a method using the Chrome Debug Protocol
+     * @param method Chrome Debug Protocol method to execute
+     * @param params
+     * @returns
+     */
+    async inspectorPost(method, params) {
+        if (!this.debuggerStatus) {
+            throw kerror.get('core', 'debugger', 'not_enabled');
+        }
+        let resolve;
+        const promise = new Promise(res => {
+            resolve = res;
+        });
+        this.inspector.post(method, params, (err, res) => {
+            if (err) {
+                resolve({ error: JSON.stringify(Object.getOwnPropertyDescriptors(err)) });
+            }
+            else {
+                resolve(res);
+            }
+        });
+        return promise;
+    }
+    /**
+     * Sends a direct notification to a websocket connection without having to listen to a specific room
+     */
+    async notifyConnection(connectionId, event, payload) {
+        global.kuzzle.entryPoint._notify({
+            channels: [event],
+            connectionId,
+            payload,
+        });
+    }
+    async notifyGlobalListeners(event, payload) {
+        const listeners = this.events.get('*');
+        if (!listeners) {
+            return;
+        }
+        const promises = [];
+        for (const connectionId of listeners) {
+            promises.push(this.notifyConnection(connectionId, DEBUGGER_EVENT, {
+                event,
+                result: payload
+            }));
+        }
+        // No need to catch, notify is already try-catched
+        await Promise.all(promises);
+    }
+}
+exports.DebugController = DebugController;
+//# sourceMappingURL=debugController.js.map

package/lib/api/controllers/documentController.js

@@ -30,37 +30,51 @@ const {
 } = require('../../util/requestAssertions');
 const extractFields = require('../../util/extractFields');
 const { dumpCollectionDocuments } = require('../../util/dump-collection');
+/**
+ * @description actions available on the document Controller (used by generic events)
+ * @key actions
+ * @value event type (empty for actions that are not linked to events)
+ */
+const actions = {
+  count: '',
+  create: 'write',
+  createOrReplace: 'write',
+  delete: 'delete',
+  deleteByQuery: 'delete',
+  deleteFields: 'update',
+  exists: 'get',
+  export: 'get',
+  get: 'get',
+  mCreate: 'write',
+  mCreateOrReplace: 'write',
+  mDelete: 'delete',
+  mExists: 'get',
+  mGet: 'get',
+  mReplace: 'write',
+  mUpdate: 'update',
+  mUpsert: 'update',
+  replace: 'write',
+  scroll: '',
+  search: 'get',
+  update: 'update',
+  updateByQuery: 'update',
+  upsert: 'update',
+  validate: '',
+};
+
 /**
  * @class DocumentController
  */
 class DocumentController extends NativeController {
   constructor () {
-    super([
-      'count',
-      'create',
-      'createOrReplace',
-      'delete',
-      'deleteByQuery',
-      'deleteFields',
-      'exists',
-      'export',
-      'get',
-      'mCreate',
-      'mCreateOrReplace',
-      'mDelete',
-      'mExists',
-      'mGet',
-      'mReplace',
-      'mUpdate',
-      'mUpsert',
-      'replace',
-      'scroll',
-      'search',
-      'update',
-      'upsert',
-      'updateByQuery',
-      'validate'
-    ]);
+    super(Object.keys(actions));
+  }
+
+  /**
+   * @returns {Record<string, unknown>}
+   */
+  static get actions () {
+    return actions;
   }
 
   /**
@@ -69,8 +83,8 @@ class DocumentController extends NativeController {
    */
   async search (request) {
     const { from, size, scrollTTL, searchBody } = request.getSearchParams();
-    const index = request.input.args.index;
-    const collection = request.input.args.collection;
+    const index = request.getIndex({ required: false });
+    const collection = request.getCollection({ required: false });
     const targets = request.getArray('targets', []);
     const lang = request.getLangParam();
 
@@ -118,7 +132,7 @@ class DocumentController extends NativeController {
         searchBody,
         { from, scroll: scrollTTL, size });
     }
-    
+
     return {
       aggregations: result.aggregations,
       hits: result.hits,
@@ -228,8 +242,12 @@ class DocumentController extends NativeController {
       mimeType = 'text/csv';
     }
 
-    request.response.setHeader('Content-Type', mimeType);
-    request.response.setHeader('Content-Disposition', `attachment; filename="${index}-${collection}.${format}"`);
+    request.response.configure({
+      headers: {
+        'Content-Disposition': `attachment; filename="${index}-${collection}.${format}"`,
+        'Content-Type': mimeType,
+      }
+    });
 
     return dumpCollectionDocuments(
       index,

package/lib/api/controllers/index.js

@@ -27,6 +27,7 @@ module.exports = {
   BulkController: require('./bulkController'),
   ClusterController: require('./clusterController'),
   CollectionController: require('./collectionController'),
+  DebugController: require('./debugController').DebugController,
   DocumentController: require('./documentController'),
   IndexController: require('./indexController'),
   MemoryStorageController: require('./memoryStorageController'),

package/lib/api/controllers/indexController.js

@@ -21,8 +21,6 @@
 
 'use strict';
 
-const Bluebird = require('bluebird');
-
 const { Request } = require('../request');
 const { NativeController } = require('./baseController');
 
@@ -119,7 +117,7 @@ class IndexController extends NativeController {
         );
       }
 
-      await Bluebird.all(promises);
+      await Promise.all(promises);
     }
 
     return response;
@@ -148,12 +146,18 @@ class IndexController extends NativeController {
   }
 
   /**
-   * Returns a list of indexes allowed to be deleted by the user
+   * Returns a list of indexes allowed to be deleted by the user.
+   *
+   * Returns entire list of public indexes when called from EmbeddedSDK
    *
    * @param {Request} request
-   * @param {String[]} publicIndexes - Complete indexes list
+   * @param {String[]} publicIndexes - Public indexes list
    */
   _allowedIndexes (request, publicIndexes) {
+    if (request.getUser() === null) {
+      return publicIndexes;
+    }
+
     const allowedIndexes = [];
 
     const promises = publicIndexes
@@ -171,7 +175,7 @@ class IndexController extends NativeController {
           });
       });
 
-    return Bluebird.all(promises)
+    return Promise.all(promises)
       .then(() => allowedIndexes);
   }
 }