kuzzle 2.59.0 → 2.60.0-beta.2

package/dist/lib/types/storage/8/Elasticsearch.d.ts

@@ -14,22 +14,23 @@ export type KUpdateResponse = {
     _source: unknown;
     _version: number;
 };
+/** `size` is in bytes: `store.size_in_bytes`, never the human-readable form. */
 export type KStatsIndexesCollection = {
     documentCount: number;
     name: string;
-    size: estypes.ByteSize;
+    size: number;
 };
 export type KStatsIndex = {
     collections: KStatsIndexesCollection[];
     name: string;
-    size: estypes.ByteSize;
+    size: number;
 };
 export type KStatsIndexes = {
     [key: string]: KStatsIndex;
 };
 export type KStats = {
     indexes: KStatsIndex[];
-    size: estypes.ByteSize;
+    size: number;
 };
 export type { JSONObject } from "../../JSONObject";
 export type KImportError = {

package/dist/lib/util/array.d.ts

@@ -8,4 +8,4 @@
  * - [0] Both value are equals
  * @returns {number} The index of the value, or -1 if not found
  */
-export declare function binarySearch(array: any[], predicate: (value: any) => number): number;
+export declare function binarySearch<T>(array: readonly T[], predicate: (value: T) => number): number;

package/dist/lib/util/array.js

@@ -20,7 +20,7 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.binarySearch = void 0;
+exports.binarySearch = binarySearch;
 /**
  * Binary Search
  *
@@ -34,13 +34,15 @@ exports.binarySearch = void 0;
 function binarySearch(array, predicate) {
     let lowerBound = 0;
     let upperBound = array.length - 1;
-    if (array.length === 1) {
-        return predicate(array[0]) === 0 ? 0 : -1;
-    }
     while (lowerBound <= upperBound) {
         // 5x faster than Math.floor((lowerBound + upperBound) / 2)
         const index = (lowerBound + upperBound) >> 1;
-        const comparison = predicate(array[index]);
+        const value = array[index];
+        // Only a hole or an `undefined` element: the index is within bounds.
+        if (value === undefined) {
+            return -1;
+        }
+        const comparison = predicate(value);
         if (comparison < 0) {
             upperBound = index - 1;
         }
@@ -53,5 +55,4 @@ function binarySearch(array, predicate) {
     }
     return -1;
 }
-exports.binarySearch = binarySearch;
 //# sourceMappingURL=array.js.map

package/dist/lib/util/assertType.js

@@ -20,7 +20,11 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertInteger = exports.assertString = exports.assertArray = exports.assertArrayOrObject = exports.assertObject = void 0;
+exports.assertObject = assertObject;
+exports.assertArrayOrObject = assertArrayOrObject;
+exports.assertArray = assertArray;
+exports.assertString = assertString;
+exports.assertInteger = assertInteger;
 const errors_1 = require("../kerror/errors");
 /**
  * The first overload is what the callers in `lib/api/request` need: they hand
@@ -37,7 +41,6 @@ function assertObject(attr, data) {
     }
     return data;
 }
-exports.assertObject = assertObject;
 /**
  * Throws if the provided data is not an object or an array.
  * Returns the unmodified data if validated
@@ -55,7 +58,6 @@ function assertArrayOrObject(attr, data) {
     }
     return data;
 }
-exports.assertArrayOrObject = assertArrayOrObject;
 /**
  * The overload above is not a claim the implementation does not make: every
  * element that reaches the returned array has been checked with
@@ -79,7 +81,6 @@ function assertArray(attr, data, type) {
     }
     return clone;
 }
-exports.assertArray = assertArray;
 /**
  * Throws if the provided data is not a string
  * Returns the unmodified data if validated
@@ -97,7 +98,6 @@ function assertString(attr, data) {
     }
     return data;
 }
-exports.assertString = assertString;
 /**
  * Throws if the provided data is not an integer
  * Returns the unmodified data if validated
@@ -112,5 +112,4 @@ function assertInteger(attr, data) {
     }
     return data;
 }
-exports.assertInteger = assertInteger;
 //# sourceMappingURL=assertType.js.map

package/dist/lib/util/async.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.promiseAllN = void 0;
+exports.promiseAllN = promiseAllN;
 /*
  * Resolve promises with a limited concurrency number
  *
@@ -70,5 +70,4 @@ function promiseAllN(collection, n = 100) {
     }
     return pendingPromise;
 }
-exports.promiseAllN = promiseAllN;
 //# sourceMappingURL=async.js.map

package/dist/lib/util/asyncStore.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { AsyncLocalStorage } from "async_hooks";
 type Store = Map<string, unknown>;
 type RunCallback = () => void;

package/dist/lib/util/bufferedPassThrough.d.ts

@@ -1,6 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
 import stream from "stream";
 type Encoding = BufferEncoding | "buffer";
 type ChunkData = Buffer | string;

package/dist/lib/util/crypto.js

@@ -3,10 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sha256 = void 0;
+exports.sha256 = sha256;
 const crypto_1 = __importDefault(require("crypto"));
 function sha256(string) {
     return crypto_1.default.createHash("sha256").update(string).digest("hex");
 }
-exports.sha256 = sha256;
 //# sourceMappingURL=crypto.js.map

package/dist/lib/util/debug.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="lib/types/debug" />
 import "../types/Global";
 declare function createDebug(namespace: string): import("debug").Debugger;
 export = createDebug;

package/dist/lib/util/debug.js

@@ -35,13 +35,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };

package/dist/lib/util/distributedLock.d.ts

@@ -25,6 +25,28 @@ export interface MutexConfig {
 export declare class MutexLockLostError extends Error {
     constructor(key: string, cause?: Error);
 }
+/**
+ * Thrown by `withLock` when the lock cannot be acquired within its retry
+ * attempts: the callback did not run.
+ */
+export declare class MutexAcquireError extends Error {
+    constructor(key: string, attempts: number);
+}
+/**
+ * Frees every lock taken by `withLock` that this process still holds, and
+ * stops it from taking new ones. Only meant to be called right before
+ * `process.exit`, which skips the `finally` that would release them.
+ *
+ * A process that exits holding a lock leaves it in Redis until its TTL
+ * expires, and every node waiting on it waits that long (step 15, F-13).
+ *
+ * From then on, `withLock` never settles and never runs its callback: the
+ * process is about to exit, and rejecting would send the caller down a path
+ * meant for a lock held by another node.
+ *
+ * Internal to Kuzzle: not exported by the package.
+ */
+export declare function releaseAllLocksBeforeExit(): Promise<void>;
 /**
  * Runs `callback` while holding a distributed, reentrant lock on `key`.
  *
@@ -36,7 +58,8 @@ export declare class MutexLockLostError extends Error {
  *
  * The lock's TTL is extended in the background while `callback` runs. If
  * the lock cannot be acquired within `retryAttempts + 1` attempts, the
- * returned promise rejects without running `callback`.
+ * returned promise rejects with `MutexAcquireError` without running
+ * `callback`.
  *
  * If the lock is lost mid-callback (e.g. TTL extension failed and another
  * node may now hold it), the returned promise rejects with
@@ -44,9 +67,9 @@ export declare class MutexLockLostError extends Error {
  * be cancelled and keeps running in the background; do not perform
  * authoritative side effects after observing this rejection.
  *
- * Do not use on the same resource key as the deprecated `Mutex` class
- * concurrently: both write to the same Redis key with incompatible
- * value/TTL formats and will contend with (but never corrupt) each other.
+ * The deprecated `Mutex` class takes the same Redis key with `SET NX`: on
+ * the same resource, the two exclude each other, and neither can release
+ * the other's lock.
  *
  * @param key - resource identifier to be locked (must be identical across
  *              all nodes)

package/dist/lib/util/distributedLock.js

@@ -23,7 +23,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.withLock = exports.MutexLockLostError = void 0;
+exports.MutexAcquireError = exports.MutexLockLostError = void 0;
+exports.releaseAllLocksBeforeExit = releaseAllLocksBeforeExit;
+exports.withLock = withLock;
 const node_async_hooks_1 = require("node:async_hooks");
 const redis_semaphore_1 = require("redis-semaphore");
 const debug_1 = __importDefault(require("./debug"));
@@ -41,6 +43,17 @@ class MutexLockLostError extends Error {
     }
 }
 exports.MutexLockLostError = MutexLockLostError;
+/**
+ * Thrown by `withLock` when the lock cannot be acquired within its retry
+ * attempts: the callback did not run.
+ */
+class MutexAcquireError extends Error {
+    constructor(key, attempts) {
+        super(`Failed to acquire lock "${key}" after ${attempts} attempts`);
+        this.name = "MutexAcquireError";
+    }
+}
+exports.MutexAcquireError = MutexAcquireError;
 /**
  * redis-semaphore's mutex, adjusted to what `withLock` promises:
  *
@@ -78,6 +91,29 @@ class ResourceMutex extends redis_semaphore_1.Mutex {
  */
 const lockContext = new node_async_hooks_1.AsyncLocalStorage();
 let clientPromise;
+// Every lock this process holds, so that it can give them back before it
+// exits (see `releaseAllLocksBeforeExit`).
+const held = new Set();
+let exiting = false;
+/**
+ * Frees every lock taken by `withLock` that this process still holds, and
+ * stops it from taking new ones. Only meant to be called right before
+ * `process.exit`, which skips the `finally` that would release them.
+ *
+ * A process that exits holding a lock leaves it in Redis until its TTL
+ * expires, and every node waiting on it waits that long (step 15, F-13).
+ *
+ * From then on, `withLock` never settles and never runs its callback: the
+ * process is about to exit, and rejecting would send the caller down a path
+ * meant for a lock held by another node.
+ *
+ * Internal to Kuzzle: not exported by the package.
+ */
+async function releaseAllLocksBeforeExit() {
+    exiting = true;
+    // Best effort: a lock that cannot be freed still expires with its TTL.
+    await Promise.allSettled([...held].map((mutex) => mutex.release()));
+}
 /**
  * Lazily fetches and memoizes the internal cache's raw ioredis client.
  * Self-healing: if the very first call happens before the cache engine has
@@ -103,7 +139,8 @@ async function getClient() {
  *
  * The lock's TTL is extended in the background while `callback` runs. If
  * the lock cannot be acquired within `retryAttempts + 1` attempts, the
- * returned promise rejects without running `callback`.
+ * returned promise rejects with `MutexAcquireError` without running
+ * `callback`.
  *
  * If the lock is lost mid-callback (e.g. TTL extension failed and another
  * node may now hold it), the returned promise rejects with
@@ -111,9 +148,9 @@ async function getClient() {
  * be cancelled and keeps running in the background; do not perform
  * authoritative side effects after observing this rejection.
  *
- * Do not use on the same resource key as the deprecated `Mutex` class
- * concurrently: both write to the same Redis key with incompatible
- * value/TTL formats and will contend with (but never corrupt) each other.
+ * The deprecated `Mutex` class takes the same Redis key with `SET NX`: on
+ * the same resource, the two exclude each other, and neither can release
+ * the other's lock.
  *
  * @param key - resource identifier to be locked (must be identical across
  *              all nodes)
@@ -121,8 +158,11 @@ async function getClient() {
  * @param config - lock options (ignored if this call is reentrant)
  */
 async function withLock(key, callback, config = {}) {
-    const held = lockContext.getStore();
-    if (held?.has(key)) {
+    if (exiting) {
+        return new Promise(() => undefined);
+    }
+    const ancestors = lockContext.getStore();
+    if (ancestors?.has(key)) {
         return callback();
     }
     const { retryAttempts = 10, retryDelay = 200, ttl = 30000 } = config;
@@ -142,25 +182,38 @@ async function withLock(key, callback, config = {}) {
         onLockLost: (error) => {
             loss.abort(new MutexLockLostError(key, mutex.refreshError ?? error));
         },
-        retryInterval: retryDelay,
+        // redis-semaphore waits `retryInterval` after every failed attempt, the
+        // last one included: with no retry, that wait only delays the failure
+        retryInterval: retryAttempts === 0 ? 0 : retryDelay,
     });
     if (!(await mutex.tryAcquire())) {
-        throw new Error(`Failed to acquire lock "${key}" after ${retryAttempts + 1} attempts`);
+        throw new MutexAcquireError(key, retryAttempts + 1);
+    }
+    held.add(mutex);
+    // Acquired while `releaseAllLocksBeforeExit` was running: give it back at once
+    if (exiting) {
+        await releaseQuietly(mutex, key);
+        return new Promise(() => undefined);
     }
     try {
-        const nextHeld = new Set(held);
+        const nextHeld = new Set(ancestors);
         nextHeld.add(key);
         const callbackPromise = lockContext.run(nextHeld, () => callback());
         // Settles as soon as the lock is lost, without waiting for the callback
         return await Promise.race([callbackPromise, lockLost]);
     }
     finally {
-        // A failed release only leaves the key to expire with its TTL: it must
-        // not replace the callback's own outcome
-        await mutex.release().catch((error) => {
-            debug("Failed to release lock %s: %s", key, error);
-        });
+        await releaseQuietly(mutex, key);
     }
 }
-exports.withLock = withLock;
+/**
+ * A failed release only leaves the key to expire with its TTL: it must not
+ * replace the callback's own outcome
+ */
+async function releaseQuietly(mutex, key) {
+    held.delete(mutex);
+    await mutex.release().catch((error) => {
+        debug("Failed to release lock %s: %s", key, error);
+    });
+}
 //# sourceMappingURL=distributedLock.js.map

package/dist/lib/util/dump-collection.d.ts

@@ -34,5 +34,5 @@ export declare function extractMappingFields(mapping: JSONObject): JSONObject;
  * @returns The values in the same order as the fields
  * @see https://lodash.com/docs/4.17.15#values
  */
-export declare function pickValues(object: any, fields: string[]): any[];
-export declare function dumpCollectionDocuments(index: string, collection: string, query?: any, format?: string, fields?: string[], options?: JSONObject): HttpStream;
+export declare function pickValues(object: unknown, fields: string[]): unknown[];
+export declare function dumpCollectionDocuments(index: string, collection: string, query?: JSONObject, format?: string, fields?: string[], options?: JSONObject): HttpStream;

package/dist/lib/util/dump-collection.js

@@ -15,18 +15,31 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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.dumpCollectionDocuments = exports.pickValues = exports.extractMappingFields = exports.flattenObject = void 0;
+exports.flattenObject = flattenObject;
+exports.extractMappingFields = extractMappingFields;
+exports.pickValues = pickValues;
+exports.dumpCollectionDocuments = dumpCollectionDocuments;
 const get_1 = __importDefault(require("lodash/get"));
 const isObject_1 = __importDefault(require("lodash/isObject"));
 const ndjson_1 = __importDefault(require("ndjson"));
@@ -56,7 +69,6 @@ function flattenObject(target) {
     flattenStep(output, target);
     return output;
 }
-exports.flattenObject = flattenObject;
 function flattenStep(output, object, prev = null) {
     for (const [key, value] of Object.entries(object)) {
         const newKey = prev ? prev + "." + key : key;
@@ -89,7 +101,6 @@ function extractMappingFields(mapping) {
     }
     return newMapping;
 }
-exports.extractMappingFields = extractMappingFields;
 /**
  * An iteration-order-safe version of lodash.values
  *
@@ -101,7 +112,6 @@ exports.extractMappingFields = extractMappingFields;
 function pickValues(object, fields) {
     return fields.map((f) => formatValueForCSV((0, get_1.default)(object, f)));
 }
-exports.pickValues = pickValues;
 /**
  * Formats the value for correct CSV output, avoiding to return
  * values that would badly serialize in CSV.
@@ -240,7 +250,7 @@ class JSONLDumper extends AbstractDumper {
     }
 }
 class CSVDumper extends AbstractDumper {
-    constructor(index, collection, query = {}, writeStream, options, fields) {
+    constructor(index, collection, query, writeStream, options, fields) {
         super(index, collection, query, writeStream, options);
         this.fields = fields;
     }
@@ -298,5 +308,4 @@ function dumpCollectionDocuments(index, collection, query = {}, format = "jsonl"
     }
     return new types_1.HttpStream(writableStream);
 }
-exports.dumpCollectionDocuments = dumpCollectionDocuments;
 //# sourceMappingURL=dump-collection.js.map

package/dist/lib/util/esRequest.js

@@ -23,7 +23,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getESIndexDynamicSettings = void 0;
+exports.getESIndexDynamicSettings = getESIndexDynamicSettings;
 const lodash_1 = __importDefault(require("lodash"));
 // Dynamic index settings specified in the elasticsearch documentation :
 // https://www.elastic.co/guide/en/elasticsearch/reference/7.5/index-modules.html#index-modules-settings
@@ -58,5 +58,4 @@ const dynamicESSettings = [
 function getESIndexDynamicSettings(requestSettings) {
     return lodash_1.default.pick(requestSettings, dynamicESSettings);
 }
-exports.getESIndexDynamicSettings = getESIndexDynamicSettings;
 //# sourceMappingURL=esRequest.js.map

package/dist/lib/util/extractFields.d.ts

@@ -2,6 +2,15 @@ interface ExtractedField {
     key: string;
     value: unknown;
 }
+interface ExtractOptions {
+    fieldsToIgnore?: string[];
+    alsoExtractValues?: boolean;
+}
+/** The recursion's own arguments: not for callers. */
+interface ExtractState {
+    path?: string | null;
+    extractedFields?: Array<string | ExtractedField>;
+}
 /**
  * Extract nested fields of an object in a flat array.
  * Example: { field : { 1: "nested", 2: "nested" } } => [ 'field.1', 'field.2' ]
@@ -11,11 +20,11 @@ interface ExtractedField {
  *
  * @returns Array of field paths, or of { key, value } pairs when alsoExtractValues is true
  */
-declare function extractFields(document: Record<string, unknown>, { fieldsToIgnore, alsoExtractValues, }?: {
-    fieldsToIgnore?: string[];
-    alsoExtractValues?: boolean;
-}, { path, extractedFields, }?: {
-    path?: string | null;
-    extractedFields?: Array<string | ExtractedField>;
-}): Array<string | ExtractedField>;
+declare function extractFields(document: Record<string, unknown>, options: ExtractOptions & {
+    alsoExtractValues: true;
+}): ExtractedField[];
+declare function extractFields(document: Record<string, unknown>, options?: ExtractOptions & {
+    alsoExtractValues?: false;
+}): string[];
+declare function extractFields(document: Record<string, unknown>, options?: ExtractOptions, state?: ExtractState): Array<string | ExtractedField>;
 export = extractFields;

package/dist/lib/util/extractFields.js

@@ -20,16 +20,7 @@
  * limitations under the License.
  */
 const safeObject_1 = require("./safeObject");
-/**
- * Extract nested fields of an object in a flat array.
- * Example: { field : { 1: "nested", 2: "nested" } } => [ 'field.1', 'field.2' ]
- *
- * @param document - Document to extract fields from
- * @param options - alsoExtractValues (false), fieldsToIgnore ( [ ] )
- *
- * @returns Array of field paths, or of { key, value } pairs when alsoExtractValues is true
- */
-function extractFields(document, { fieldsToIgnore = [], alsoExtractValues = false, } = {}, { path = null, extractedFields = [], } = {}) {
+function extractFields(document, { fieldsToIgnore = [], alsoExtractValues = false } = {}, { path = null, extractedFields = [] } = {}) {
     for (const [key, value] of Object.entries(document)) {
         if (fieldsToIgnore.includes(key)) {
             continue;

package/dist/lib/util/koncordeCompat.js

@@ -35,15 +35,29 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getIndexes = exports.getCollections = exports.koncordeTest = exports.fromKoncordeIndex = exports.toKoncordeIndex = void 0;
+exports.toKoncordeIndex = toKoncordeIndex;
+exports.fromKoncordeIndex = fromKoncordeIndex;
+exports.koncordeTest = koncordeTest;
+exports.getCollections = getCollections;
+exports.getIndexes = getIndexes;
 /*
   Set of utility functions meant to ease up the use of Koncorde v4 in Kuzzle
  */
@@ -63,7 +77,6 @@ const fatal = kerror.wrap("core", "fatal");
 function toKoncordeIndex(index, collection) {
     return `${index}${SEPARATOR}${collection}`;
 }
-exports.toKoncordeIndex = toKoncordeIndex;
 /**
  * Returns an index+collection pair from a Koncorde v4 index name
  *
@@ -85,7 +98,6 @@ function fromKoncordeIndex(index) {
         index: kindex,
     };
 }
-exports.fromKoncordeIndex = fromKoncordeIndex;
 /**
  * Quick compat method to start a Koncorde test
  *
@@ -104,7 +116,6 @@ function koncordeTest(koncorde, index, collection, body, _id) {
     const data = _id ? Object.assign({}, body, { _id }) : body;
     return koncorde.test(data, indexV4);
 }
-exports.koncordeTest = koncordeTest;
 /**
  * Extracts the list of Koncorde indexes and translate them into a
  * Kuzzle collections list
@@ -120,7 +131,6 @@ function getCollections(koncorde, index) {
         .filter((i) => i.startsWith(indexPrefix))
         .map((i) => i.substr(indexPrefix.length));
 }
-exports.getCollections = getCollections;
 /**
  * Extracts the list of Koncorde indexes and translate them into a
  * Kuzzle indexes list
@@ -135,5 +145,4 @@ function getIndexes(koncorde) {
         .map((i) => i.substr(0, i.indexOf(SEPARATOR)));
     return (0, lodash_1.uniq)(indexes);
 }
-exports.getIndexes = getIndexes;
 //# sourceMappingURL=koncordeCompat.js.map

package/dist/lib/util/mutex.d.ts

@@ -35,10 +35,10 @@ export interface MutexOptions {
  * synchronization between servers (see https://redis.io/topics/distlock)
  *
  * @deprecated Use `withLock` from `./distributedLock` instead: it supports
- * real Redlock semantics and reentrancy. Do not mix `Mutex` and `withLock`
- * on the same resource key — they use incompatible acquisition/TTL formats
- * and will contend with (though never corrupt) each other's lock on that
- * key.
+ * real Redlock semantics and reentrancy. `Mutex` and `withLock` take the
+ * same Redis key with `SET NX`, so they exclude each other on the same
+ * resource (which keeps old and new nodes apart during a rolling upgrade),
+ * and neither can release the other's lock.
  */
 export declare class Mutex {
     readonly resource: string;