kuzzle 2.31.0-elasticsearch-8.2 → 2.32.0-elasticsearch-8.1

package/lib/api/controllers/memoryStorageController.js

@@ -267,11 +267,15 @@ function initMapping() {
           kassert.assertBodyAttributeType(request, "entries", "array");
 
           val.forEach((v) => {
-            if (typeof v !== "object" || !v.field || !v.value) {
+            if (
+              typeof v !== "object" ||
+              !v.field ||
+              (!v.value && v.value !== 0)
+            ) {
               throw kerror.get(
                 "invalid_argument",
                 "entries",
-                "<array of object>",
+                "<array of objects>",
               );
             }
 
@@ -348,7 +352,11 @@ function initMapping() {
           kassert.assertBodyHasAttribute(request, "entries");
           kassert.assertBodyAttributeType(request, "entries", "array");
           val.forEach((entry) => {
-            if (typeof entry !== "object" || !entry.key || !entry.value) {
+            if (
+              typeof entry !== "object" ||
+              !entry.key ||
+              (!entry.value && entry.value !== 0)
+            ) {
               throw kerror.get(
                 "invalid_argument",
                 "entries",

package/lib/api/funnel.js

@@ -753,6 +753,10 @@ class Funnel {
    */
   async executePluginRequest(request) {
     try {
+      if (request.input.triggerEvents) {
+        const response = await this.processRequest(request);
+        return { ...response.result };
+      }
       return await doAction(this.getController(request), request);
     } catch (e) {
       this.handleErrorDump(e);

package/lib/api/request/requestInput.d.ts

@@ -135,6 +135,8 @@ export declare class RequestInput {
      */
     get action(): string | null;
     set action(str: string);
+    get triggerEvents(): boolean | undefined;
+    set triggerEvents(bool: boolean);
     /**
      * Request body.
      * In Http it's the request body parsed.

package/lib/api/request/requestInput.js

@@ -54,6 +54,7 @@ const _body = "body\u200b";
 const _headers = "headers\u200b";
 const _controller = "controller\u200b";
 const _action = "action\u200b";
+const _triggerEvents = "triggerEvents\u200b";
 // any property not listed here will be copied into
 // RequestInput.args
 const resourceProperties = new Set([
@@ -126,6 +127,7 @@ class RequestInput {
         this[_body] = null;
         this[_controller] = null;
         this[_action] = null;
+        this[_triggerEvents] = null;
         // default value to null for former "resources" to avoid breaking
         this.args = {};
         this.resource = new RequestResource(this.args);
@@ -147,6 +149,7 @@ class RequestInput {
         this.body = data.body;
         this.controller = data.controller;
         this.action = data.action;
+        this.triggerEvents = data.triggerEvents;
     }
     /**
      * Authentication token.
@@ -223,6 +226,12 @@ class RequestInput {
             this[_action] = assert.assertString("action", str);
         }
     }
+    get triggerEvents() {
+        return this[_triggerEvents];
+    }
+    set triggerEvents(bool) {
+        this[_triggerEvents] = bool === true ? true : undefined;
+    }
     /**
      * Request body.
      * In Http it's the request body parsed.

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

@@ -29,7 +29,6 @@ type UpdateOptions = {
  */
 export declare class ProfileRepository extends ObjectRepository<Profile> {
     private module;
-    private profiles;
     /**
      * @constructor
      */
@@ -42,7 +41,9 @@ export declare class ProfileRepository extends ObjectRepository<Profile> {
      * @returns {Promise.<Promise>}
      * @throws {NotFoundError} If the corresponding profile doesn't exist
      */
-    load(id: string): Promise<Profile>;
+    load(id: string, options?: {
+        key?: string;
+    }): Promise<Profile>;
     /**
      * Loads a Profile object given its id.
      * Stores the promise of the profile being loaded in the memcache
@@ -140,16 +141,6 @@ export declare class ProfileRepository extends ObjectRepository<Profile> {
      * @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.
@@ -168,8 +159,8 @@ export declare class ProfileRepository extends ObjectRepository<Profile> {
      * @param policy
      */
     private optimizePolicy;
-    toDTO(dto: Profile): Promise<JSONObject>;
-    deleteFromDatabase(id: string, options: JSONObject): Promise<any>;
+    toDTO(dto: Profile): JSONObject;
+    deleteFromDatabase(id: string, options: JSONObject): any;
     search(searchBody: JSONObject, options: JSONObject): Promise<{
         aggregations: any;
         hits: any[];

package/lib/core/security/profileRepository.js

@@ -51,7 +51,6 @@ const bluebird_1 = __importDefault(require("bluebird"));
 const lodash_1 = require("lodash");
 const kerror = __importStar(require("../../kerror"));
 const profile_1 = require("../../model/security/profile");
-const cacheDbEnum_1 = require("../cache/cacheDbEnum");
 const ObjectRepository_1 = require("../shared/ObjectRepository");
 /**
  * @class ProfileRepository
@@ -62,12 +61,8 @@ class ProfileRepository extends ObjectRepository_1.ObjectRepository {
      * @constructor
      */
     constructor(securityModule) {
-        super({
-            cache: cacheDbEnum_1.cacheDbEnum.NONE,
-            store: global.kuzzle.internalIndex,
-        });
+        super({ store: global.kuzzle.internalIndex });
         this.module = securityModule;
-        this.profiles = new Map();
         this.collection = "profiles";
         this.ObjectConstructor = profile_1.Profile;
     }
@@ -111,7 +106,7 @@ class ProfileRepository extends ObjectRepository_1.ObjectRepository {
          *
          * @param  {String} [id] - profile identifier
          */
-        global.kuzzle.onAsk("core:security:profile:invalidate", (id) => this.invalidate(id));
+        global.kuzzle.onAsk("core:security:profile:invalidate", (id) => this.deleteFromCache(id));
         /**
          * Gets multiple profiles
          * @param  {Array} ids
@@ -156,13 +151,18 @@ class ProfileRepository extends ObjectRepository_1.ObjectRepository {
      * @returns {Promise.<Promise>}
      * @throws {NotFoundError} If the corresponding profile doesn't exist
      */
-    async load(id) {
-        if (this.profiles.has(id)) {
-            return this.profiles.get(id);
+    async load(id, options = {}) {
+        const profile = await this.loadFromCache(id, options);
+        if (profile === null) {
+            const profileFromDatabase = await this.loadOneFromDatabase(id);
+            if (profileFromDatabase !== null) {
+                await this.persistToCache(profileFromDatabase);
+                profileFromDatabase.optimizedPolicies = this.optimizePolicies(profileFromDatabase.policies);
+            }
+            return profileFromDatabase;
         }
-        const profile = await super.load(id);
         profile.optimizedPolicies = this.optimizePolicies(profile.policies);
-        this.profiles.set(id, profile);
+        await this.refreshCacheTTL(profile);
         return profile;
     }
     /**
@@ -185,14 +185,7 @@ class ProfileRepository extends ObjectRepository_1.ObjectRepository {
             throw kerror.get("api", "assert", "invalid_type", "profileIds", "string[]");
         }
         for (const id of profileIds) {
-            let profile = this.profiles.get(id);
-            if (!profile) {
-                profile = this.loadOneFromDatabase(id).then((p) => {
-                    p.optimizedPolicies = this.optimizePolicies(p.policies);
-                    this.profiles.set(id, p);
-                    return p;
-                });
-            }
+            const profile = this.load(id);
             profiles.push(profile);
         }
         return bluebird_1.default.all(profiles);
@@ -342,7 +335,7 @@ class ProfileRepository extends ObjectRepository_1.ObjectRepository {
             }
         }
         await this.deleteFromDatabase(profile._id, { refresh });
-        this.profiles.delete(profile._id);
+        await this.deleteFromCache(profile._id);
     }
     /**
      * From a Profile object, returns a serialized object ready to be persisted
@@ -384,9 +377,9 @@ class ProfileRepository extends ObjectRepository_1.ObjectRepository {
             retryOnConflict,
         });
         const updatedProfile = await this.loadOneFromDatabase(profile._id);
+        await this.persistToCache(updatedProfile);
         // Recompute optimized policies based on new policies
         updatedProfile.optimizedPolicies = this.optimizePolicies(updatedProfile.policies);
-        this.profiles.set(profile._id, updatedProfile);
         return updatedProfile;
     }
     /**
@@ -410,32 +403,6 @@ class ProfileRepository extends ObjectRepository_1.ObjectRepository {
         }
         return profile;
     }
-    /**
-     * @override
-     */
-    async truncate(opts) {
-        try {
-            await super.truncate(opts);
-        }
-        finally {
-            // always clear the RAM cache: even if truncate fails in the middle of it,
-            // some of the cached profiles might not be valid anymore
-            this.invalidate();
-        }
-    }
-    /**
-     * Invalidate the cache entries for the given profile. If none is provided,
-     * the entire cache is emptied.
-     * @param {string} [profileId]
-     */
-    invalidate(profileId) {
-        if (!profileId) {
-            this.profiles.clear();
-        }
-        else {
-            this.profiles.delete(profileId);
-        }
-    }
     /**
      * Optimize each policy to get a O(1) index access time
      * and a O(log(n)) collection search time.
@@ -496,10 +463,10 @@ class ProfileRepository extends ObjectRepository_1.ObjectRepository {
     // Every method described after are for testing purpose only
     // Otherwise we cannot stub them
     // ============================================
-    async toDTO(dto) {
+    toDTO(dto) {
         return super.toDTO(dto);
     }
-    async deleteFromDatabase(id, options) {
+    deleteFromDatabase(id, options) {
         return super.deleteFromDatabase(id, options);
     }
     async search(searchBody, options) {

package/lib/core/security/roleRepository.js

@@ -43,7 +43,7 @@ class RoleRepository extends ObjectRepository {
    */
   constructor(securityModule) {
     super({
-      cache: cacheDbEnum.NONE,
+      cache: cacheDbEnum.INTERNAL,
       store: global.kuzzle.internalIndex,
     });
 

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

@@ -69,5 +69,5 @@ export declare class TokenRepository extends ObjectRepository<Token> {
      *
      * So we need to override the TTL auto-refresh function to disable it
      */
-    refreshCacheTTL(): void;
+    refreshCacheTTL(): Promise<void>;
 }

package/lib/core/security/tokenRepository.js

@@ -374,7 +374,7 @@ class TokenRepository extends ObjectRepository_1.ObjectRepository {
      *
      * So we need to override the TTL auto-refresh function to disable it
      */
-    refreshCacheTTL() {
+    async refreshCacheTTL() {
         // This comment is here to please Sonarqube. It requires a comment
         // explaining why a function is empty, but there is no sense
         // duplicating what has been just said in the JSDoc.

package/lib/core/shared/ObjectRepository.d.ts

@@ -117,7 +117,7 @@ export declare class ObjectRepository<TObject extends {
     refreshCacheTTL(object: JSONObject, options?: {
         key?: string;
         ttl?: number;
-    }): any;
+    }): Promise<any>;
     /**
      * @param object
      * @param options.key - if provided, stores the object to the given key instead of the default one (<collection>/<id>)

package/lib/core/shared/ObjectRepository.js

@@ -127,7 +127,7 @@ class ObjectRepository {
         let response;
         try {
             response = await global.kuzzle.ask(`core:cache:${this.cacheDb}:get`, key);
-            if (response === null) {
+            if (response === null || response === undefined) {
                 return null;
             }
             return await this.fromDTO({ ...JSON.parse(response) });

package/lib/kuzzle/event/KuzzleEventEmitter.d.ts

@@ -0,0 +1,70 @@
+import EventEmitter from "eventemitter3";
+import { AskEventDefinition, AskEventHandler, CallEventHandler, EventDefinition, HookEventHandler, PipeEventHandler } from "../../types/EventHandler";
+declare class KuzzleEventEmitter extends EventEmitter {
+    private coreAnswerers;
+    private coreSyncedAnswerers;
+    private corePipes;
+    private pipeRunner;
+    private pluginPipes;
+    private pluginPipeDefinitions;
+    private superEmit;
+    constructor(maxConcurrentPipes: number, pipesBufferSize: number);
+    /**
+     * Registers a core method on a pipe
+     * Note: core methods cannot listen to wildcarded events, only exact matching
+     * works here.
+     */
+    onPipe<TEventDefinition extends EventDefinition = EventDefinition>(event: TEventDefinition["name"], fn: PipeEventHandler<TEventDefinition>): void;
+    /**
+     * Registers a core 'ask' event answerer
+     * There can only be 0 or 1 answerer per ask event.
+     */
+    onAsk<TAskEventDefinition extends AskEventDefinition = AskEventDefinition>(event: TAskEventDefinition["name"], fn: AskEventHandler<TAskEventDefinition>): void;
+    /**
+     * Registers a core 'callback' answerer
+     * There can only be 0 or 1 answerer per callback event.
+     */
+    onCall<TAskEventDefinition extends AskEventDefinition = AskEventDefinition>(event: TAskEventDefinition["name"], fn: CallEventHandler<TAskEventDefinition>): void;
+    /**
+     * Emits an event and all its wildcarded versions
+     *
+     * @warning Critical section of code
+     */
+    emit(event: string | symbol, ...args: any[]): boolean;
+    /**
+     * Emits a pipe event, which triggers the following, in that order:
+     * 1. Plugin pipes are invoked one after another (waterfall). Each plugin must
+     *    resolve the pipe (with a callback or a promise) with a similar payload
+     *    than the one received
+     * 2. Core pipes are invoked in parallel. They are awaited for (promises-only)
+     *    but their responses are neither evaluated nor used
+     * 3. Hooks are invoked in parallel. They are not awaited.
+     *
+     * Accepts a callback argument (to be used by pipes invoked before the funnel
+     * overload-protection mechanism). If a callback is provided, this method
+     * doesn't return a promise.
+     *
+     * @warning Critical section of code
+     */
+    pipe<TEventDefinition extends EventDefinition = EventDefinition>(event: TEventDefinition["name"], ...payload: TEventDefinition["args"]): Promise<TEventDefinition["args"][0]> | null;
+    /**
+     * Emits an "ask" event to get information about the provided payload
+     */
+    ask<TAskEventDefinition extends AskEventDefinition = AskEventDefinition>(event: TAskEventDefinition["name"], ...args: [payload?: TAskEventDefinition["payload"], ...rest: any]): Promise<TAskEventDefinition["result"]>;
+    /**
+     * Calls a callback to get information about the provided payload
+     */
+    call<TAskEventDefinition extends AskEventDefinition = AskEventDefinition>(event: TAskEventDefinition["name"], ...args: [payload?: TAskEventDefinition["payload"], ...rest: any]): TAskEventDefinition["result"];
+    /**
+     * Registers a plugin hook.
+     * Catch any error in the handler and emit the hook:onError event.
+     */
+    registerPluginHook<TEventDefinition extends EventDefinition = EventDefinition>(pluginName: string, event: TEventDefinition["name"], fn: HookEventHandler<TEventDefinition>): void;
+    registerPluginPipe<TEventDefinition extends EventDefinition = EventDefinition>(event: TEventDefinition["name"], handler: PipeEventHandler<TEventDefinition>): string;
+    unregisterPluginPipe(pipeId: string): void;
+    /**
+     * Checks if an ask event has an answerer
+     */
+    hasAskAnswerer(event: string): boolean;
+}
+export default KuzzleEventEmitter;