kuzzle 2.19.0 → 2.19.3

package/lib/util/inflector.js

@@ -35,12 +35,12 @@ class Inflector {
      * @returns kebab-case-string
      */
     static kebabCase(string) {
-        return string
+        return (string
             // get all lowercase letters that are near to uppercase ones
-            .replace(/([a-z])([A-Z])/g, '$1-$2')
+            .replace(/([a-z])([A-Z])/g, "$1-$2")
             // replace all spaces and low dash
-            .replace(/[\s_]+/g, '-')
-            .toLowerCase();
+            .replace(/[\s_]+/g, "-")
+            .toLowerCase());
     }
     /**
      * Returns a string with the first letter in uppercase
@@ -54,7 +54,7 @@ class Inflector {
      * Converts a string to PascalCase
      */
     static pascalCase(string) {
-        return lodash_1.default.startCase(string).replace(/ /g, '');
+        return lodash_1.default.startCase(string).replace(/ /g, "");
     }
     /**
      * Converts a string to camelCase

package/lib/util/koncordeCompat.d.ts

@@ -1,5 +1,5 @@
-import { JSONObject } from 'kuzzle-sdk';
-import { Koncorde } from 'koncorde';
+import { JSONObject } from "kuzzle-sdk";
+import { Koncorde } from "koncorde";
 /**
  * Builds a Koncorde v4 index name from the old fashioned index+collection
  * arguments

package/lib/util/koncordeCompat.js

@@ -26,7 +26,7 @@ exports.getIndexes = exports.getCollections = exports.koncordeTest = exports.fro
  */
 const lodash_1 = require("lodash");
 // No collision possible: "/" is forbidden in index (or collection) names
-const SEPARATOR = '/';
+const SEPARATOR = "/";
 /**
  * Builds a Koncorde v4 index name from the old fashioned index+collection
  * arguments
@@ -84,8 +84,8 @@ function getCollections(koncorde, index) {
     const indexPrefix = `${index}${SEPARATOR}`;
     return koncorde
         .getIndexes()
-        .filter(i => i.startsWith(indexPrefix))
-        .map(i => i.substr(indexPrefix.length));
+        .filter((i) => i.startsWith(indexPrefix))
+        .map((i) => i.substr(indexPrefix.length));
 }
 exports.getCollections = getCollections;
 /**
@@ -98,8 +98,8 @@ exports.getCollections = getCollections;
 function getIndexes(koncorde) {
     const indexes = koncorde
         .getIndexes()
-        .filter(i => i !== '(default)')
-        .map(i => i.substr(0, i.indexOf(SEPARATOR)));
+        .filter((i) => i !== "(default)")
+        .map((i) => i.substr(0, i.indexOf(SEPARATOR)));
     return (0, lodash_1.uniq)(indexes);
 }
 exports.getIndexes = getIndexes;

package/lib/util/memoize.js

@@ -19,13 +19,11 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-function memoize (fn, resolver = null) {
+function memoize(fn, resolver = null) {
   const memoized = (...args) => {
-    const key = memoized.resolver !== null
-      ? memoized.resolver(args)
-      : args[0];
+    const key = memoized.resolver !== null ? memoized.resolver(args) : args[0];
 
     let result = memoized.cache.get(key);
 

package/lib/util/mutex.d.ts

@@ -1,4 +1,4 @@
-import '../types/Global';
+import "../types/Global";
 /**
  * Mutex class options
  */
@@ -66,5 +66,23 @@ export declare class Mutex {
      * @return {Promise}
      */
     unlock(): Promise<void>;
+    /**
+     * Wait for the resource to be unlocked.
+     * Return true if it waited until the unlocking
+     * and false if it waited until the timeout
+     *
+     * @param {Object} [Options] - mutex options
+     *    - `attemptDelay`: delay between 2 resource check (default: `this.attemptDelay`)
+     *    - `timeout`: mutex wait acquisition timeout, in milliseconds (default: `this.timeout`)
+     *                 If -1, will try to acquire the lock indefinitely.
+     *                 If 0, locking will fail immediately if it cannot lock with
+     *                 its 1st attempt.
+     *
+     * @return {Promise.<boolean>} True if the ressource has been unlocked before the `timeout`
+     */
+    wait({ attemptDelay, timeout, }: {
+        attemptDelay?: number;
+        timeout?: number;
+    }): Promise<boolean>;
     get locked(): boolean;
 }

package/lib/util/mutex.js

@@ -52,8 +52,8 @@ const bluebird_1 = __importDefault(require("bluebird"));
 const kerror = __importStar(require("../kerror"));
 const debug_1 = __importDefault(require("./debug"));
 require("../types/Global");
-const debug = (0, debug_1.default)('kuzzle:mutex');
-const fatal = kerror.wrap('core', 'fatal');
+const debug = (0, debug_1.default)("kuzzle:mutex");
+const fatal = kerror.wrap("core", "fatal");
 // LUA script for Redis: we want our mutexes to only delete the lock they
 // acquired. Prevents removing locks acquired by other processes if unlocking
 // occurs after the lock expires
@@ -98,7 +98,7 @@ class Mutex {
     constructor(resource, { attemptDelay = 200, timeout = -1, ttl = 5000 } = {}) {
         this._locked = false;
         this.resource = resource;
-        this.mutexId = `${global.kuzzle.id}/${(0, crypto_1.randomBytes)(16).toString('hex')}`;
+        this.mutexId = `${global.kuzzle.id}/${(0, crypto_1.randomBytes)(16).toString("hex")}`;
         this.attemptDelay = attemptDelay;
         this.timeout = timeout;
         this.ttl = ttl;
@@ -112,21 +112,22 @@ class Mutex {
      */
     async lock() {
         if (this._locked) {
-            throw fatal.get('assertion_failed', `resource "${this.resource}" already locked by this mutex (id: ${this.mutexId})`);
+            throw fatal.get("assertion_failed", `resource "${this.resource}" already locked by this mutex (id: ${this.mutexId})`);
         }
         let duration = 0;
         do {
-            this._locked = await global.kuzzle.ask('core:cache:internal:store', this.resource, this.mutexId, { onlyIfNew: true, ttl: this.ttl });
+            this._locked = await global.kuzzle.ask("core:cache:internal:store", this.resource, this.mutexId, { onlyIfNew: true, ttl: this.ttl });
             duration += this.attemptDelay;
             if (!this._locked && (this.timeout === -1 || duration <= this.timeout)) {
                 await bluebird_1.default.delay(this.attemptDelay);
             }
-        } while (!this._locked && (this.timeout === -1 || duration <= this.timeout));
+        } while (!this._locked &&
+            (this.timeout === -1 || duration <= this.timeout));
         if (!this._locked) {
-            debug('Failed to lock %s (mutex id: %s)', this.resource, this.mutexId);
+            debug("Failed to lock %s (mutex id: %s)", this.resource, this.mutexId);
             return false;
         }
-        debug('Resource %s locked (mutex id: %s)', this.resource, this.mutexId);
+        debug("Resource %s locked (mutex id: %s)", this.resource, this.mutexId);
         return true;
     }
     /**
@@ -136,15 +137,41 @@ class Mutex {
      */
     async unlock() {
         if (!this._locked) {
-            throw fatal.get('assertion_failed', `tried to unlock the resource "${this.resource}", which is not locked (mutex id: ${this.mutexId})`);
+            throw fatal.get("assertion_failed", `tried to unlock the resource "${this.resource}", which is not locked (mutex id: ${this.mutexId})`);
         }
         if (!delScriptRegistered) {
-            await global.kuzzle.ask('core:cache:internal:script:define', 'delIfValueEqual', 1, delIfValueEqualLua);
+            await global.kuzzle.ask("core:cache:internal:script:define", "delIfValueEqual", 1, delIfValueEqualLua);
             delScriptRegistered = true;
         }
-        await global.kuzzle.ask('core:cache:internal:script:execute', 'delIfValueEqual', this.resource, this.mutexId);
+        await global.kuzzle.ask("core:cache:internal:script:execute", "delIfValueEqual", this.resource, this.mutexId);
         this._locked = false;
-        debug('Resource %s freed (mutex id: %s)', this.resource, this.mutexId);
+        debug("Resource %s freed (mutex id: %s)", this.resource, this.mutexId);
+    }
+    /**
+     * Wait for the resource to be unlocked.
+     * Return true if it waited until the unlocking
+     * and false if it waited until the timeout
+     *
+     * @param {Object} [Options] - mutex options
+     *    - `attemptDelay`: delay between 2 resource check (default: `this.attemptDelay`)
+     *    - `timeout`: mutex wait acquisition timeout, in milliseconds (default: `this.timeout`)
+     *                 If -1, will try to acquire the lock indefinitely.
+     *                 If 0, locking will fail immediately if it cannot lock with
+     *                 its 1st attempt.
+     *
+     * @return {Promise.<boolean>} True if the ressource has been unlocked before the `timeout`
+     */
+    async wait({ attemptDelay = this.attemptDelay, timeout = this.timeout, }) {
+        let duration = 0;
+        let isLocked = true;
+        do {
+            isLocked = await global.kuzzle.ask("core:cache:internal:get", this.resource);
+            duration += attemptDelay;
+            if (isLocked && (timeout === -1 || duration <= timeout)) {
+                await bluebird_1.default.delay(attemptDelay);
+            }
+        } while (isLocked && (timeout === -1 || duration <= timeout));
+        return !isLocked;
     }
     get locked() {
         return this._locked;