kuzzle 2.56.0 → 2.57.0-beta.2

package/dist/lib/util/assertType.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,110 +19,98 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const { BadRequestError } = require("../kerror/errors");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertInteger = exports.assertString = exports.assertArray = exports.assertArrayOrObject = exports.assertObject = void 0;
+const errors_1 = require("../kerror/errors");
 /**
- * Throws if the provided data is not an object.
- * Returns the unmodified data if validated
- *
- * @throws
- * @param {string} attr - tested attribute name
- * @param {*} data
- * @return {object}
+ * The first overload is what the callers in `lib/api/request` need: they hand
+ * it a value they already have a type for and want it back, not widened to a
+ * bare record. The second is the original signature, kept because the function
+ * has to accept anything in order to reject it.
  */
 function assertObject(attr, data) {
     if (data === null || data === undefined) {
         return null;
     }
     if (typeof data !== "object" || Array.isArray(data)) {
-        throw new BadRequestError(`Attribute ${attr} must be of type "object"`);
+        throw new errors_1.BadRequestError(`Attribute ${attr} must be of type "object"`);
     }
     return data;
 }
+exports.assertObject = assertObject;
 /**
  * Throws if the provided data is not an object or an array.
  * Returns the unmodified data if validated
  *
  * @throws
- * @param {string} attr - tested attribute name
- * @param {*} data
- * @return {object|array}
+ * @param attr - tested attribute name
+ * @param data
  */
 function assertArrayOrObject(attr, data) {
     if (data === null || data === undefined) {
         return null;
     }
     if (typeof data !== "object") {
-        throw new BadRequestError(`Attribute ${attr} must be of type "object" or "array"`);
+        throw new errors_1.BadRequestError(`Attribute ${attr} must be of type "object" or "array"`);
     }
     return data;
 }
+exports.assertArrayOrObject = assertArrayOrObject;
 /**
- * Throws if the provided data is not an array containing exclusively
- * values of the specified "type"
- * Returns a clone of the provided array if valid
- *
- * @throws
- * @param {string} attr - tested attribute name
- * @param {*} data
- * @return {array}
+ * The overload above is not a claim the implementation does not make: every
+ * element that reaches the returned array has been checked with
+ * `typeof d !== type`, so a call with `"string"` really does answer `string[]`.
  */
 function assertArray(attr, data, type) {
     if (data === null || data === undefined) {
         return [];
     }
     if (!Array.isArray(data)) {
-        throw new BadRequestError(`Attribute ${attr} must be of type "array"`);
+        throw new errors_1.BadRequestError(`Attribute ${attr} must be of type "array"`);
     }
     const clone = [];
     for (const d of data) {
         if (d !== undefined && d !== null) {
             if (typeof d !== type) {
-                throw new BadRequestError(`Attribute ${attr} must contain only values of type "${type}"`);
+                throw new errors_1.BadRequestError(`Attribute ${attr} must contain only values of type "${type}"`);
             }
             clone.push(d);
         }
     }
     return clone;
 }
+exports.assertArray = assertArray;
 /**
  * Throws if the provided data is not a string
  * Returns the unmodified data if validated
  *
  * @throws
- * @param {string} attr - tested attribute name
- * @param {*} data
- * @return {null|string}
+ * @param attr - tested attribute name
+ * @param data
  */
 function assertString(attr, data) {
     if (data === null || data === undefined) {
         return null;
     }
     if (typeof data !== "string") {
-        throw new BadRequestError(`Attribute ${attr} must be of type "string"`);
+        throw new errors_1.BadRequestError(`Attribute ${attr} must be of type "string"`);
     }
     return data;
 }
+exports.assertString = assertString;
 /**
  * Throws if the provided data is not an integer
  * Returns the unmodified data if validated
  *
  * @throws
- * @param {string} attr - tested attribute name
- * @param {*} data
- * @return {number}
+ * @param attr - tested attribute name
+ * @param data
  */
 function assertInteger(attr, data) {
     if (!Number.isInteger(data)) {
-        throw new BadRequestError(`Attribute ${attr} must be an integer`);
+        throw new errors_1.BadRequestError(`Attribute ${attr} must be an integer`);
     }
     return data;
 }
-module.exports = {
-    assertArray,
-    assertArrayOrObject,
-    assertInteger,
-    assertObject,
-    assertString,
-};
+exports.assertInteger = assertInteger;
 //# sourceMappingURL=assertType.js.map

package/dist/lib/util/async.js

@@ -8,23 +8,36 @@ exports.promiseAllN = void 0;
  * https://gist.github.com/jcouyang/632709f30e12a7879a73e9e132c0d56b
  */
 function promiseAllN(collection, n = 100) {
+    // An empty collection resolves to an empty list. The guard clause this
+    // replaces read `return resolve([])`, which answers `undefined` — the
+    // resolver's return value — rather than the promise it had just settled.
+    if (collection.length === 0) {
+        return Promise.resolve([]);
+    }
     let i = 0;
     let jobsLeft = collection.length;
     const outcome = [];
     let rejected = false;
     // create a new promise and capture reference to resolve and reject to avoid nesting of code
-    let resolve, reject;
+    let resolve = () => undefined;
+    let reject = () => undefined;
     const pendingPromise = new Promise((res, rej) => {
         resolve = res;
         reject = rej;
     });
-    // Guard clause
-    if (collection.length === 0) {
-        return resolve([]);
-    }
     // execute the j'th thunk
     function runJob(j) {
-        collection[j]()
+        const job = collection[j];
+        // `j` is always an index into `collection` — the bootstrap below and the
+        // `i < collection.length` check are what keep it one.
+        if (job === undefined) {
+            return;
+        }
+        // `Reflect.apply` with the collection as the receiver: `collection[j]()`
+        // passed the array as `this`, and hoisting the lookup out of the call is
+        // how that gets dropped silently. Every caller hands arrows, so nothing
+        // reads it — preserved rather than re-decided.
+        Reflect.apply(job, collection, [])
             .then((result) => {
             if (rejected) {
                 return; // no op!

package/dist/lib/util/asyncStore.js

@@ -62,7 +62,7 @@ class AsyncStore {
     }
     _getStore() {
         const store = this._asyncLocalStorage.getStore();
-        (0, assert_1.default)(Boolean(store), "Associated AsyncStore is not set");
+        (0, assert_1.default)(store !== undefined, "Associated AsyncStore is not set");
         return store;
     }
 }

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

@@ -74,5 +74,14 @@ export declare class BufferedPassThrough extends stream.Duplex {
      * @param callback
      */
     _destroy(err: Error, callback: Callback): void;
+    /**
+     * Pushes whatever the buffer still holds, closes the stream and releases the
+     * buffer. Both `_final` and `_destroy` end up here, and `_destroy` may run
+     * after `_final` has already flushed — resetting the offset is what stops the
+     * tail being pushed twice. It used to be `this.buffer = null` that stopped
+     * it, which made the declared `Buffer` a lie the two call sites had to
+     * maintain.
+     */
+    private flushAndClose;
 }
 export {};

package/dist/lib/util/bufferedPassThrough.js

@@ -25,6 +25,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BufferedPassThrough = void 0;
 const stream_1 = __importDefault(require("stream"));
+const DEFAULT_BUFFER_SIZE = 8196;
 /**
  * This streams accumulate chunks data into a buffer until the amount of data is equal or exceed  the buffer size.
  * Then, it emits a single chunk with the accumulated data.
@@ -33,10 +34,16 @@ const stream_1 = __importDefault(require("stream"));
  * This can helps reducing the number of syscall made by the stream consumer.
  */
 class BufferedPassThrough extends stream_1.default.Duplex {
-    constructor(options = { highWaterMark: 8196 }) {
-        super(options);
-        this.bufferSize = options.highWaterMark;
-        this.buffer = Buffer.alloc(options.highWaterMark);
+    constructor(options) {
+        // `highWaterMark` is optional on DuplexOptions, so it is resolved once and
+        // handed to both the stream and the internal buffer. It used to be a
+        // default argument, which covered the no-argument call and nothing else:
+        // `new BufferedPassThrough({})` reached `Buffer.alloc(undefined)`, which
+        // throws.
+        const highWaterMark = options?.highWaterMark ?? DEFAULT_BUFFER_SIZE;
+        super({ ...options, highWaterMark });
+        this.bufferSize = highWaterMark;
+        this.buffer = Buffer.alloc(highWaterMark);
         this.offset = 0;
     }
     /**
@@ -133,12 +140,7 @@ class BufferedPassThrough extends stream_1.default.Duplex {
      * @param callback
      */
     _final(callback) {
-        if (this.buffer && this.offset > 0) {
-            // Push last bit of data
-            this.push(this.buffer.slice(0, this.offset));
-        }
-        this.push(null); // Close the stream
-        this.buffer = null;
+        this.flushAndClose();
         callback();
     }
     /**
@@ -148,13 +150,25 @@ class BufferedPassThrough extends stream_1.default.Duplex {
      * @param callback
      */
     _destroy(err, callback) {
-        if (this.buffer && this.offset > 0) {
+        this.flushAndClose();
+        callback(err);
+    }
+    /**
+     * Pushes whatever the buffer still holds, closes the stream and releases the
+     * buffer. Both `_final` and `_destroy` end up here, and `_destroy` may run
+     * after `_final` has already flushed — resetting the offset is what stops the
+     * tail being pushed twice. It used to be `this.buffer = null` that stopped
+     * it, which made the declared `Buffer` a lie the two call sites had to
+     * maintain.
+     */
+    flushAndClose() {
+        if (this.offset > 0) {
             // Push last bit of data
             this.push(this.buffer.slice(0, this.offset));
+            this.offset = 0;
         }
         this.push(null); // Close the stream
-        this.buffer = null;
-        callback(err);
+        this.buffer = Buffer.alloc(0);
     }
 }
 exports.BufferedPassThrough = BufferedPassThrough;

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

@@ -1,2 +1,2 @@
+declare function bytes(input: unknown): number | null;
 export = bytes;
-declare function bytes(input: any): number;

package/dist/lib/util/bytes.js

@@ -19,11 +19,15 @@ function bytes(input) {
     else if (input.toLowerCase().includes("tb")) {
         unit = 1024 ** 4;
     }
-    const match = input.match(/\d+/);
+    const match = /\d+/.exec(input);
     if (!match) {
         return null;
     }
-    const number = parseInt(match[0], 10);
+    const [digits] = match;
+    if (digits === undefined) {
+        return null;
+    }
+    const number = Number.parseInt(digits, 10);
     if (Number.isNaN(number)) {
         return null;
     }

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

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

package/dist/lib/util/debug.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,24 +19,55 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const debug = require("debug");
-const util = require("util");
-debug.formatters.a = (value) => {
-    const inspectOpts = debug.inspectOpts;
+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 };
+};
+const util = __importStar(require("node:util"));
+const debug_1 = __importDefault(require("debug"));
+require("../types/Global");
+debug_1.default.formatters.a = (value) => {
+    const inspectOpts = debug_1.default.inspectOpts;
     if (inspectOpts.expand) {
         return `\n${util.inspect(value, inspectOpts)}`;
     }
-    return util.inspect(value, inspectOpts).replace(/\s*\n\s*/g, " ");
+    // Collapse whitespace runs that contain a newline into a single space,
+    // leaving newline-free whitespace untouched. A single `\s+` scan with a
+    // predicate avoids the super-linear backtracking of `\s*\n\s*`.
+    return util
+        .inspect(value, inspectOpts)
+        .replace(/\s+/g, (match) => (match.includes("\n") ? " " : match));
 };
-debug.formatArgs = () => { };
+debug_1.default.formatArgs = () => { };
 function createDebug(namespace) {
-    const myDebug = debug(namespace);
-    myDebug.log = (...args) => {
+    const myDebug = (0, debug_1.default)(namespace);
+    myDebug.log = (msg, ...args) => {
         if (!["debug", "trace"].includes(global.kuzzle.log.level)) {
             global.kuzzle.log.level = "debug";
         }
-        global.kuzzle.log.debug({ namespace }, ...args);
+        global.kuzzle.log.debug({ namespace }, msg, ...args);
     };
     return myDebug;
 }

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

@@ -1 +1,9 @@
-export function deprecateProperties(logger: any, target: any, deprecations?: {}): any;
+import "../types/Global";
+interface DeprecationLogger {
+    warn: (...args: unknown[]) => void;
+}
+type Deprecations = Record<string, string | {
+    message?: string;
+} | null>;
+export declare const deprecateProperties: <T extends object>(logger: DeprecationLogger, target: T, deprecations?: Deprecations) => T;
+export {};

package/dist/lib/util/deprecate.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,7 +19,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deprecateProperties = void 0;
+require("../types/Global");
 const deprecationWarning = (logger, ...args) => {
     if (global.NODE_ENV === "development") {
         logger.warn("DEPRECATION WARNING");
@@ -26,11 +29,14 @@ const deprecationWarning = (logger, ...args) => {
     }
 };
 const warnIfDeprecated = (logger, deprecations, member) => {
-    const deprecatedProperty = Object.keys(deprecations).find((deprecated) => deprecated === member), alternative = deprecations[deprecatedProperty];
+    const deprecatedProperty = Object.keys(deprecations).find((deprecated) => deprecated === member);
     if (!deprecatedProperty) {
         return;
     }
-    if (alternative && typeof alternative.message === "string") {
+    const alternative = deprecations[deprecatedProperty];
+    if (alternative &&
+        typeof alternative === "object" &&
+        typeof alternative.message === "string") {
         deprecationWarning(logger, alternative.message);
     }
     else if (typeof alternative === "string") {
@@ -58,7 +64,5 @@ const deprecateProperties = (logger, target, deprecations = {}) => {
         },
     });
 };
-module.exports = {
-    deprecateProperties,
-};
+exports.deprecateProperties = deprecateProperties;
 //# sourceMappingURL=deprecate.js.map

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

@@ -1,2 +1,3 @@
+import "../types/Global";
+declare function printDidYouMean(str: string, list: readonly string[]): string;
 export = printDidYouMean;
-declare function printDidYouMean(...args: any[]): string;

package/dist/lib/util/didYouMean.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,13 +19,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const didYouMean = require("didyoumean");
-function printDidYouMean(...args) {
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const didyoumean_1 = __importDefault(require("didyoumean"));
+require("../types/Global");
+function printDidYouMean(str, list) {
     if (global.NODE_ENV !== "development") {
         return "";
     }
-    const result = didYouMean(...args);
+    const result = (0, didyoumean_1.default)(str, list);
     if (!result) {
         return "";
     }

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

@@ -0,0 +1,56 @@
+import "../types/Global";
+/**
+ * withLock() options
+ */
+export interface MutexConfig {
+    /**
+     * Number of acquisition retries after the first failed attempt, i.e. at
+     * most `retryAttempts + 1` attempts are made (default: 10)
+     */
+    retryAttempts?: number;
+    /**
+     * Delay between 2 lock acquisition attempts, in milliseconds (default: 200)
+     */
+    retryDelay?: number;
+    /**
+     * Lock TTL in milliseconds (default: 30000)
+     */
+    ttl?: number;
+}
+/**
+ * Thrown when a lock acquired by `withLock` is lost while its callback is
+ * still running (e.g. TTL extension failed and another node may now hold
+ * the lock).
+ */
+export declare class MutexLockLostError extends Error {
+    constructor(key: string, cause?: Error);
+}
+/**
+ * Runs `callback` while holding a distributed, reentrant lock on `key`.
+ *
+ * Reentrant: if the current async context already holds `key` (i.e. this is
+ * a nested call from inside another `withLock(key, ...)` call for the same
+ * key), `callback` runs immediately with no new Redis round-trip, and
+ * `config` is silently ignored (the ancestor's lock/TTL/retry settings
+ * apply — this is correct reentrant-mutex semantics, not a bug).
+ *
+ * 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`.
+ *
+ * If the lock is lost mid-callback (e.g. TTL extension failed and another
+ * node may now hold it), the returned promise rejects with
+ * `MutexLockLostError` as soon as that's detected. `callback` itself cannot
+ * 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.
+ *
+ * @param key - resource identifier to be locked (must be identical across
+ *              all nodes)
+ * @param callback - executed while the lock is held
+ * @param config - lock options (ignored if this call is reentrant)
+ */
+export declare function withLock<T>(key: string, callback: () => Promise<T>, config?: MutexConfig): Promise<T>;