kuzzle 2.18.1 → 2.19.2

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/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,

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/securityController.js

@@ -32,7 +32,7 @@ const formatProcessing = require('../../core/auth/formatProcessing');
 const ApiKey = require('../../model/storage/apiKey');
 const kerror = require('../../kerror');
 const { has } = require('../../util/safeObject');
-const { generateRandomName } = require('../../util/name-generator');
+const { NameGenerator } = require('../../util/name-generator');
 
 /**
  * @class SecurityController
@@ -1273,7 +1273,7 @@ class SecurityController extends NativeController {
     const credentials = request.getBodyObject('credentials', {});
     const strategies = Object.keys(credentials);
     const generator = humanReadableId
-      ? () => generateRandomName('kuid')
+      ? () => NameGenerator.generateRandomName({ prefix: 'kuid' })
       : () => 'kuid-' + uuidv4();
 
     let id = '';

package/lib/api/documentExtractor.js

@@ -26,6 +26,27 @@ const kerror = require('../kerror');
 const assertionError = kerror.wrap('api', 'assert');
 
 const extractors = ([
+  {
+    methods: {
+      extractFromRequest: request => [
+        {
+          _id: request.input.args._id,
+          _source: request.input.body.fields,
+        },
+      ],
+      extractFromResult: request => [request.result],
+      insertInRequest: ([documents], request) => {
+        request.input.args._id = documents._id;
+        request.input.body.fields = documents._source;
+        return request;
+      },
+      insertInResult: ([document], request) => {
+        request.setResult(document, { status: request.status });
+        return request;
+      },
+    },
+    targets: [ 'deleteFields' ]
+  },
   {
     methods: {
       extractFromRequest: request => [{ _id: request.input.args._id }],
@@ -39,7 +60,7 @@ const extractors = ([
         return request;
       }
     },
-    targets: ['delete', 'get']
+    targets: [ 'delete', 'get', 'exists' ]
   },
   {
     methods: {
@@ -118,7 +139,7 @@ const extractors = ([
         return request;
       }
     },
-    targets: ['mDelete', 'mGet']
+    targets: [ 'mDelete', 'mGet', 'mExists' ]
   },
   {
     methods: {
@@ -128,21 +149,41 @@ const extractors = ([
         for (let it = 0; it < request.input.body.documents.length; it++) {
           const document = request.input.body.documents[it];
 
-          documents.push({ _id: document._id, _source: document.body });
+          if (request.input.action === 'mUpsert') {
+            documents.push({
+              _id: document._id,
+              _source: document.changes,
+            });
+          }
+          else {
+            documents.push({ _id: document._id, _source: document.body });
+          }
         }
 
         return documents;
       },
       extractFromResult: request => request.result.successes,
       insertInRequest: (documents, request) => {
+        const tmpDocuments = request.input.body.documents;
+
         request.input.body.documents = [];
 
         for (let it = 0; it < documents.length; it++) {
           const document = documents[it];
 
-          request.input.body.documents.push({
-            _id: document._id,
-            body: document._source });
+          if (request.input.action === 'mUpsert') {
+            request.input.body.documents.push({
+              _id: document._id,
+              changes: document._source,
+              default: tmpDocuments[it].default,
+            });
+          }
+          else {
+            request.input.body.documents.push({
+              _id: document._id,
+              body: document._source,
+            });
+          }
         }
 
         return request;
@@ -158,7 +199,7 @@ const extractors = ([
         return request;
       }
     },
-    targets: ['mCreate', 'mCreateOrReplace', 'mReplace', 'mUpdate', 'updateByQuery']
+    targets: [ 'mCreate', 'mCreateOrReplace', 'mReplace', 'mUpdate', 'updateByQuery', 'mUpsert' ]
   },
   {
     methods: {
@@ -178,7 +219,7 @@ const extractors = ([
         return request;
       },
     },
-    targets: ['search', 'deleteByQuery'],
+    targets: [ 'search', 'deleteByQuery', 'export' ],
   },
   {
     methods: {