kuzzle 2.56.0 → 2.57.0-beta.2

package/dist/lib/kerror/errors/serviceUnavailableError.d.ts

@@ -1,4 +1,4 @@
 import { KuzzleError } from "./kuzzleError";
 export declare class ServiceUnavailableError extends KuzzleError {
-    constructor(message: any, id?: any, code?: any);
+    constructor(message?: unknown, id?: unknown, code?: unknown);
 }

package/dist/lib/kerror/errors/serviceUnavailableError.js

@@ -23,7 +23,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServiceUnavailableError = void 0;
 const kuzzleError_1 = require("./kuzzleError");
 class ServiceUnavailableError extends kuzzleError_1.KuzzleError {
-    constructor(message, id, code) {
+    constructor(message = "", id, code) {
         super(message, 503, id, code);
     }
 }

package/dist/lib/kerror/errors/sizeLimitError.d.ts

@@ -1,4 +1,4 @@
 import { KuzzleError } from "./kuzzleError";
 export declare class SizeLimitError extends KuzzleError {
-    constructor(message: any, id?: any, code?: any);
+    constructor(message?: unknown, id?: unknown, code?: unknown);
 }

package/dist/lib/kerror/errors/sizeLimitError.js

@@ -23,7 +23,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SizeLimitError = void 0;
 const kuzzleError_1 = require("./kuzzleError");
 class SizeLimitError extends kuzzleError_1.KuzzleError {
-    constructor(message, id, code) {
+    constructor(message = "", id, code) {
         super(message, 413, id, code);
     }
 }

package/dist/lib/kerror/errors/tooManyRequestsError.d.ts

@@ -1,4 +1,4 @@
 import { KuzzleError } from "./kuzzleError";
 export declare class TooManyRequestsError extends KuzzleError {
-    constructor(message: any, id?: any, code?: any);
+    constructor(message?: unknown, id?: unknown, code?: unknown);
 }

package/dist/lib/kerror/errors/tooManyRequestsError.js

@@ -23,7 +23,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TooManyRequestsError = void 0;
 const kuzzleError_1 = require("./kuzzleError");
 class TooManyRequestsError extends kuzzleError_1.KuzzleError {
-    constructor(message, id, code) {
+    constructor(message = "", id, code) {
         super(message, 429, id, code);
     }
 }

package/dist/lib/kerror/errors/unauthorizedError.d.ts

@@ -1,4 +1,4 @@
 import { KuzzleError } from "./kuzzleError";
 export declare class UnauthorizedError extends KuzzleError {
-    constructor(message: any, id?: any, code?: any);
+    constructor(message?: unknown, id?: unknown, code?: unknown);
 }

package/dist/lib/kerror/errors/unauthorizedError.js

@@ -23,7 +23,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnauthorizedError = void 0;
 const kuzzleError_1 = require("./kuzzleError");
 class UnauthorizedError extends kuzzleError_1.KuzzleError {
-    constructor(message, id, code) {
+    constructor(message = "", id, code) {
         super(message, 401, id, code);
     }
 }

package/dist/lib/kerror/index.d.ts

@@ -1,6 +1,6 @@
 import type { Domains } from "./codes";
 import * as errors from "./errors";
-import { KuzzleError } from "./errors";
+import type { KuzzleError } from "./errors";
 /**
  * Construct and return the corresponding error
  *
@@ -11,7 +11,7 @@ import { KuzzleError } from "./errors";
  * @param  placeholders - Placeholders value to inject in error message
  * @param  options - Last param can be additional options { message }
  */
-export declare function rawGet(domains: Domains, domain: string, subdomain: string, error: string, ...placeholders: any[]): KuzzleError;
+export declare function rawGet(domains: Domains, domain: string, subdomain: string, error: string, ...placeholders: unknown[]): KuzzleError;
 /**
  * Returns a promise rejected with the corresponding error
  *
@@ -21,7 +21,7 @@ export declare function rawGet(domains: Domains, domain: string, subdomain: stri
  * @param  error - Error name: (eg: 'index_not_found')
  * @param  placeholders - Placeholders value to inject in error message
  */
-export declare function rawReject(domains: Domains, domain: string, subdomain: string, error: string, ...placeholders: any[]): Promise<any>;
+export declare function rawReject(domains: Domains, domain: string, subdomain: string, error: string, ...placeholders: unknown[]): Promise<any>;
 /**
  * Construct and return the corresponding error, with its stack
  * trace derivated from a provided source error
@@ -33,14 +33,20 @@ export declare function rawReject(domains: Domains, domain: string, subdomain: s
  * @param  error - Error name: (eg: 'index_not_found')
  * @param  placeholders - Placeholders value to inject in error message
  */
-export declare function rawGetFrom(domains: Domains, source: Error, domain: string, subdomain: string, error: string, ...placeholders: any[]): KuzzleError;
+export declare function rawGetFrom(domains: Domains, 
+/**
+ * Whatever was thrown. `unknown`, not `Error`: the only thing read off it
+ * is a stack, if it has one, and `pipeRunner` derives from what a plugin
+ * rejected with — which may be a string.
+ */
+source: unknown, domain: string, subdomain: string, error: string, ...placeholders: unknown[]): KuzzleError;
 /**
  * Wrap error functions with the provided domain and subdomain.
  */
 export declare function rawWrap(domains: Domains, domain: string, subdomain: string): {
-    get: (error: any, ...placeholders: any[]) => errors.KuzzleError;
-    getFrom: (source: any, error: any, ...placeholders: any[]) => errors.KuzzleError;
-    reject: (error: any, ...placeholders: any[]) => Promise<any>;
+    get: (error: string, ...placeholders: unknown[]) => errors.KuzzleError;
+    getFrom: (source: unknown, error: string, ...placeholders: unknown[]) => errors.KuzzleError;
+    reject: (error: string, ...placeholders: unknown[]) => Promise<any>;
 };
 /**
  * Construct and return the corresponding error
@@ -51,7 +57,7 @@ export declare function rawWrap(domains: Domains, domain: string, subdomain: str
  * @param  placeholders - Placeholders value to inject in error message
  * @param  options - Last param can be additional options { message }
  */
-export declare function get(domain: string, subdomain: string, error: string, ...placeholders: any[]): KuzzleError;
+export declare function get(domain: string, subdomain: string, error: string, ...placeholders: unknown[]): KuzzleError;
 /**
  * Returns a promise rejected with the corresponding error
  *
@@ -60,7 +66,7 @@ export declare function get(domain: string, subdomain: string, error: string, ..
  * @param  error - Error name: (eg: 'index_not_found')
  * @param  placeholders - Placeholders value to inject in error message
  */
-export declare function reject(domain: string, subdomain: string, error: string, ...placeholders: any[]): Promise<any>;
+export declare function reject(domain: string, subdomain: string, error: string, ...placeholders: unknown[]): Promise<any>;
 /**
  * Construct and return the corresponding error, with its stack
  * trace derivated from a provided source error
@@ -71,12 +77,12 @@ export declare function reject(domain: string, subdomain: string, error: string,
  * @param  error - Error name: (eg: 'index_not_found')
  * @param  placeholders - Placeholders value to inject in error message
  */
-export declare function getFrom(source: Error, domain: string, subdomain: string, error: string, ...placeholders: any[]): KuzzleError;
+export declare function getFrom(source: unknown, domain: string, subdomain: string, error: string, ...placeholders: unknown[]): KuzzleError;
 /**
  * Wrap error functions with the provided domain and subdomain.
  */
 export declare function wrap(domain: string, subdomain: string): {
-    get: (error: any, ...placeholders: any[]) => errors.KuzzleError;
-    getFrom: (source: any, error: any, ...placeholders: any[]) => errors.KuzzleError;
-    reject: (error: any, ...placeholders: any[]) => Promise<any>;
+    get: (error: string, ...placeholders: unknown[]) => errors.KuzzleError;
+    getFrom: (source: unknown, error: string, ...placeholders: unknown[]) => errors.KuzzleError;
+    reject: (error: string, ...placeholders: unknown[]) => Promise<any>;
 };

package/dist/lib/kerror/index.js

@@ -42,27 +42,41 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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.wrap = exports.getFrom = exports.reject = exports.get = exports.rawWrap = exports.rawGetFrom = exports.rawReject = exports.rawGet = void 0;
 const util_1 = require("util");
-const lodash_1 = __importDefault(require("lodash"));
 const codes_1 = require("./codes");
 const errors = __importStar(require("./errors"));
+const lodash_1 = require("lodash");
 /**
  * Gets this file name in the exact same format than the one printed in the
  * stacktraces (used to clean kerror lines from stacktraces)
+ *
+ * `module` is a CommonJS global. Kuzzle ships as CommonJS, but vitest loads
+ * `lib/` as ESM, where `module` is undefined — and reading `.filename` off it
+ * threw, which made EVERY vitest spec that reaches an error path crash. The
+ * guard degrades gracefully instead: with no filename to match, stack-trace
+ * cleaning is skipped, which is cosmetic.
  */
 let _currentFileName = null;
 function _getCurrentFileName() {
     if (_currentFileName !== null) {
         return _currentFileName;
     }
-    _currentFileName = module.filename.substr(process.cwd().length + 1);
+    _currentFileName =
+        typeof module === "undefined" || !module.filename
+            ? ""
+            : module.filename.substring(process.cwd().length + 1);
     return _currentFileName;
 }
+/**
+ * Whether the last placeholder is the options object: an object literal
+ * only. A class instance is a placeholder like any other value, so it is
+ * formatted into the message rather than taken for options.
+ */
+function isOptions(value) {
+    return (0, lodash_1.isPlainObject)(value);
+}
 /**
  * Construct and return the corresponding error
  *
@@ -76,23 +90,34 @@ function _getCurrentFileName() {
 function rawGet(domains, domain, subdomain, error, ...placeholders) {
     let options = {};
     // extract options object from the placeholders
-    if (lodash_1.default.isPlainObject(placeholders[placeholders.length - 1])) {
-        options = placeholders.pop();
+    const last = placeholders.at(-1);
+    if (isOptions(last)) {
+        options = last;
+        placeholders.pop();
     }
-    const kuzzleError = lodash_1.default.get(domains, `${domain}.subDomains.${subdomain}.errors.${error}`);
-    if (!kuzzleError) {
+    // Walked rather than fetched through a dotted `_.get` path: the three
+    // levels are what the code below reads the codes off, the guard then covers
+    // all three at once, and the `as any as ErrorDefinition` that the string
+    // path required is gone with it.
+    const domainEntry = domains[domain];
+    const subdomainEntry = domainEntry?.subDomains[subdomain];
+    const kuzzleError = subdomainEntry?.errors[error];
+    if (!domainEntry || !subdomainEntry || !kuzzleError) {
         return get("core", "fatal", "unexpected_error", `${domain}.${subdomain}.${error}`);
     }
-    let body = null;
+    let body;
     if (kuzzleError.class === "PartialError" ||
         kuzzleError.class === "MultipleErrorsError") {
-        body = placeholders.splice(-1)[0];
+        const [partials] = placeholders.splice(-1);
+        // The documented shape is the list of partial errors. Anything else was
+        // handed to the constructor and dropped there — `Array.isArray(body)` is
+        // the only thing it does with it — so the check moves to where the type
+        // is decided.
+        body = Array.isArray(partials) ? partials : undefined;
     }
     const message = options.message || (0, util_1.format)(kuzzleError.message, ...placeholders);
     const id = `${domain}.${subdomain}.${error}`;
-    const code = (domains[domain].code << 24) |
-        (domains[domain].subDomains[subdomain].code << 16) |
-        domains[domain].subDomains[subdomain].errors[error].code;
+    const code = (domainEntry.code << 24) | (subdomainEntry.code << 16) | kuzzleError.code;
     let kerror;
     if (kuzzleError.class === "PartialError" ||
         kuzzleError.class === "MultipleErrorsError") {
@@ -105,7 +130,10 @@ function rawGet(domains, domain, subdomain, error, ...placeholders) {
     else {
         kerror = new errors[kuzzleError.class](message, id, code);
     }
-    kerror.props = placeholders;
+    // Not `kerror.props = placeholders`: `props` is declared `string[]`, which
+    // is what code compiled against v2.56.0 reads, and a placeholder may be
+    // anything. See KuzzleError.props.
+    Object.assign(kerror, { props: placeholders });
     if (kuzzleError.class !== "InternalError") {
         cleanStackTrace(kerror);
     }
@@ -124,6 +152,11 @@ exports.rawGet = rawGet;
  *  at ControllerManager.add (kuzzle/lib/core/backend/backend.ts:226:34)
  */
 function cleanStackTrace(error) {
+    // `Error.stack` is not guaranteed — `Error.stackTraceLimit = 0` removes it,
+    // and there is nothing to trim off an error that has none.
+    if (error.stack === undefined) {
+        return;
+    }
     // Keep the original error message
     const messageLength = error.message.split("\n").length;
     const currentFileName = _getCurrentFileName();
@@ -134,8 +167,10 @@ function cleanStackTrace(error) {
         if (index < messageLength) {
             return true;
         }
-        // filter all lines related to the kerror object
-        return !line.includes(currentFileName);
+        // filter all lines related to the kerror object. An empty
+        // `currentFileName` (see above) matches everything, so guard it: no
+        // filename means no filtering.
+        return currentFileName === "" || !line.includes(currentFileName);
     });
     // insert a deletion message in place of the new error instantiation line
     newStack[messageLength] = "      [...Kuzzle internal calls deleted...]";
@@ -165,11 +200,17 @@ exports.rawReject = rawReject;
  * @param  error - Error name: (eg: 'index_not_found')
  * @param  placeholders - Placeholders value to inject in error message
  */
-function rawGetFrom(domains, source, domain, subdomain, error, ...placeholders) {
+function rawGetFrom(domains, 
+/**
+ * Whatever was thrown. `unknown`, not `Error`: the only thing read off it
+ * is a stack, if it has one, and `pipeRunner` derives from what a plugin
+ * rejected with — which may be a string.
+ */
+source, domain, subdomain, error, ...placeholders) {
     const derivedError = rawGet(domains, domain, subdomain, error, ...placeholders);
     // If a stacktrace is present, we need to modify the first line because it
     // still contains the original error message
-    if (derivedError?.stack?.length && source?.stack) {
+    if (derivedError?.stack?.length && source instanceof Error && source.stack) {
         const stackArray = source.stack.split("\n");
         stackArray.shift();
         derivedError.stack = [

package/dist/lib/kuzzle/Logger.d.ts

@@ -1,5 +1,5 @@
 import { KuzzleLogger } from "kuzzle-logger";
-import { KuzzleConfiguration } from "../../index";
+import type { IKuzzleConfiguration } from "../types/config/KuzzleConfiguration";
 /**
  * The Logger class provides logging functionality for Kuzzle.
  */
@@ -11,7 +11,7 @@ export declare class Logger extends KuzzleLogger {
     private static basePino;
     private warnedForSillyDeprecation;
     private warnedForVerboseDeprecation;
-    constructor(kuzzleConfig: KuzzleConfiguration, namespace?: string);
+    constructor(kuzzleConfig: IKuzzleConfiguration, namespace?: string);
     /**
      * Logs a message with the "silly" level.
      *

package/dist/lib/kuzzle/dumpGenerator.d.ts

@@ -1,14 +1,18 @@
-export = DumpGenerator;
 declare class DumpGenerator {
-    _dump: boolean;
-    logger: import("./Logger").Logger;
+    private _dump;
+    private readonly logger;
+    constructor();
     /**
      * Create a dump
-     *
-     * @param {string} suffix
-     * @returns {Promise}
      */
-    dump(suffix: string): Promise<any>;
+    dump(suffix: string): Promise<string>;
+    /**
+     * The directory this dump will be written to, or a `BadRequestError` if the
+     * suffix is malformed or would place it outside the configured dump path.
+     */
+    private _resolveDumpPath;
+    private _generate;
     _cleanUpHistory(): void;
-    _listFilesMatching(directory: any, start: any): string[];
+    _listFilesMatching(directory: string, start: string): string[];
 }
+export = DumpGenerator;

package/dist/lib/kuzzle/dumpGenerator.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,17 +19,42 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const path = require("path");
-const fs = require("fs");
-const os = require("os");
-const Bluebird = require("bluebird");
-const moment = require("moment");
-const dumpme = require("dumpme");
-const zlib = require("zlib");
-const { Request } = require("../api/request");
-const kerror = require("../kerror");
-const { BadRequestError } = require("../kerror/errors");
+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 node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_zlib_1 = __importDefault(require("node:zlib"));
+const bluebird_1 = __importDefault(require("bluebird"));
+const dumpme_1 = __importDefault(require("dumpme"));
+const moment_1 = __importDefault(require("moment"));
+const package_json_1 = __importDefault(require("../../package.json"));
+const kerror = __importStar(require("../kerror"));
+const errors_1 = require("../kerror/errors");
 class DumpGenerator {
     constructor() {
         this._dump = false;
@@ -36,49 +62,71 @@ class DumpGenerator {
     }
     /**
      * Create a dump
-     *
-     * @param {string} suffix
-     * @returns {Promise}
      */
     async dump(suffix) {
         if (this._dump) {
             throw kerror.get("api", "process", "action_locked", "dump");
         }
+        // The arguments are checked before the lock is taken, and every path out
+        // of the generation releases it: a lock held past a failure answers every
+        // later dump with `action_locked` about a dump that is not running
+        // (TD-81).
+        const dumpPath = this._resolveDumpPath(suffix);
         this._dump = true;
-        const basePath = path.normalize(global.kuzzle.config.dump.path);
-        const dumpPath = path.join(basePath, moment()
+        try {
+            return await this._generate(dumpPath);
+        }
+        finally {
+            this._dump = false;
+        }
+    }
+    /**
+     * The directory this dump will be written to, or a `BadRequestError` if the
+     * suffix is malformed or would place it outside the configured dump path.
+     */
+    _resolveDumpPath(suffix) {
+        const suffixRegex = /^[A-Za-z0-9_-]{0,64}$/;
+        if (!suffixRegex.test(suffix)) {
+            throw kerror.get("api", "assert", "invalid_argument", "suffix", "at most 64 alphanumeric characters, '-' or '_'");
+        }
+        const basePath = node_path_1.default.normalize(global.kuzzle.config.dump.path);
+        const dumpPath = node_path_1.default.join(basePath, (0, moment_1.default)()
             .format(global.kuzzle.config.dump.dateFormat)
             .concat(`-${suffix}`)
             .substring(0, 200));
-        const resolvedPath = path.resolve(dumpPath);
-        if (!resolvedPath.startsWith(path.resolve(basePath))) {
-            throw new BadRequestError(`Dump path '${dumpPath}' is outside of designated dump directory '${basePath}'`);
+        const resolvedPath = node_path_1.default.resolve(dumpPath);
+        if (!resolvedPath.startsWith(node_path_1.default.resolve(basePath) + node_path_1.default.sep)) {
+            throw new errors_1.BadRequestError(`Dump path '${dumpPath}' is outside of designated dump directory '${basePath}'`);
         }
+        return dumpPath;
+    }
+    async _generate(dumpPath) {
         this.logger.info("=".repeat(79));
         this.logger.info(`Generating dump in ${dumpPath}`);
         this._cleanUpHistory();
         try {
-            fs.mkdirSync(dumpPath, { recursive: true });
+            node_fs_1.default.mkdirSync(dumpPath, { recursive: true });
         }
         catch (e) {
-            const message = e.message.startsWith("EEXIST")
+            const error = e instanceof Error ? e : new Error(String(e));
+            const message = error.message.startsWith("EEXIST")
                 ? "Dump directory already exists. Skipping.."
-                : `Unable to create dump folder: ${e.message}`;
+                : `Unable to create dump folder: ${error.message}`;
             this.logger.error(message);
-            throw new Error(message);
+            throw new Error(message, { cause: e });
         }
         // dump kuzzle information
         this.logger.info("> dumping kuzzle configuration");
-        fs.writeFileSync(path.join(dumpPath, "kuzzle.json"), JSON.stringify({
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dumpPath, "kuzzle.json"), JSON.stringify({
             config: global.kuzzle.config,
-            version: require("../../package.json").version,
+            version: package_json_1.default.version,
         }, null, " ").concat("\n"));
         // dump plugins configuration
         this.logger.info("> dumping plugins configuration");
-        fs.writeFileSync(path.join(dumpPath, "plugins.json"), JSON.stringify(global.kuzzle.pluginsManager.getPluginsDescription(), null, " ").concat("\n"));
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dumpPath, "plugins.json"), JSON.stringify(global.kuzzle.pluginsManager.getPluginsDescription(), null, " ").concat("\n"));
         // dump Node.js configuration
         this.logger.info("> dumping Node.js configuration");
-        fs.writeFileSync(path.join(dumpPath, "nodejs.json"), JSON.stringify({
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dumpPath, "nodejs.json"), JSON.stringify({
             argv: process.argv,
             config: process.config,
             env: process.env,
@@ -88,36 +136,42 @@ class DumpGenerator {
         }, null, " ").concat("\n"));
         // dump os configuration
         this.logger.info("> dumping os configuration");
-        fs.writeFileSync(path.join(dumpPath, "os.json"), JSON.stringify({
-            cpus: os.cpus(),
-            loadavg: os.loadavg(),
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dumpPath, "os.json"), JSON.stringify({
+            cpus: node_os_1.default.cpus(),
+            loadavg: node_os_1.default.loadavg(),
             mem: {
-                free: os.freemem(),
-                total: os.totalmem(),
+                free: node_os_1.default.freemem(),
+                total: node_os_1.default.totalmem(),
             },
-            networkInterfaces: os.networkInterfaces(),
-            platform: os.platform(),
-            uptime: os.uptime(),
+            networkInterfaces: node_os_1.default.networkInterfaces(),
+            platform: node_os_1.default.platform(),
+            uptime: node_os_1.default.uptime(),
         }, null, " ").concat("\n"));
         // core-dump
         this.logger.info("> generating core-dump");
-        dumpme(global.kuzzle.config.dump.gcore || "gcore", `${dumpPath}/core`);
+        (0, dumpme_1.default)(global.kuzzle.config.dump.gcore || "gcore", `${dumpPath}/core`);
         // Gzip the core
         try {
             const corefiles = this._listFilesMatching(dumpPath, "core");
-            if (corefiles[0]) {
-                const readStream = fs.createReadStream(corefiles[0]);
-                const writeStream = fs.createWriteStream(`${dumpPath}/core.gz`);
-                await new Bluebird((resolve) => readStream
-                    .pipe(zlib.createGzip())
+            // Read once: the same element is used four times below, twice from
+            // inside a callback where the `if` above no longer narrows it.
+            const corefile = corefiles[0];
+            if (corefile) {
+                const readStream = node_fs_1.default.createReadStream(corefile);
+                const writeStream = node_fs_1.default.createWriteStream(`${dumpPath}/core.gz`);
+                await new bluebird_1.default((resolve) => readStream
+                    .pipe(node_zlib_1.default.createGzip())
                     .pipe(writeStream)
                     .on("finish", () => {
                     // rm the original core file
                     try {
-                        fs.unlinkSync(corefiles[0]);
+                        node_fs_1.default.unlinkSync(corefile);
                     }
-                    catch (e) {
-                        this.logger.warn(`> unable to clean up core file ${corefiles[0]}`);
+                    catch {
+                        // The unlink error is deliberately dropped: the core file is a
+                        // best-effort cleanup and its own path is already in the
+                        // warning.
+                        this.logger.warn(`> unable to clean up core file ${corefile}`);
                     }
                     resolve();
                 }));
@@ -131,30 +185,33 @@ class DumpGenerator {
         }
         // copy node binary
         this.logger.info("> copy node binary");
-        fs.copyFileSync(process.execPath, path.join(dumpPath, "node"));
+        node_fs_1.default.copyFileSync(process.execPath, node_path_1.default.join(dumpPath, "node"));
         // dumping Kuzzle's stats
         this.logger.info("> dumping kuzzle's stats");
-        const statistics = await global.kuzzle.statistics.getAllStats(new Request({ action: "getAllStats", controller: "statistics" }));
-        fs.writeFileSync(path.join(dumpPath, "statistics.json"), JSON.stringify(statistics.hits, null, " ").concat("\n"));
+        // `getAllStats()` takes no argument and never has: it forwards to
+        // `getStats()` with none. The `Request` the JavaScript built here was
+        // constructed and discarded on every dump.
+        const statistics = await global.kuzzle.statistics.getAllStats();
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dumpPath, "statistics.json"), JSON.stringify(statistics.hits, null, " ").concat("\n"));
         this.logger.info("Done.");
         this.logger.info("[ℹ] You can send the folder to the kuzzle core team at support@kuzzle.io");
         this.logger.info("=".repeat(79));
-        this._dump = false;
         return dumpPath;
     }
     _cleanUpHistory() {
-        const config = global.kuzzle.config.dump, dumpPath = path.normalize(global.kuzzle.config.dump.path);
+        const config = global.kuzzle.config.dump, dumpPath = node_path_1.default.normalize(global.kuzzle.config.dump.path);
         try {
-            fs.accessSync(dumpPath, fs.constants.R_OK | fs.constants.W_OK | fs.constants.X_OK);
+            node_fs_1.default.accessSync(dumpPath, node_fs_1.default.constants.R_OK | node_fs_1.default.constants.W_OK | node_fs_1.default.constants.X_OK);
         }
-        catch (e) {
+        catch {
+            // Not readable, writable and traversable: there is no history to clean.
             return;
         }
-        const dumps = fs
+        const dumps = node_fs_1.default
             .readdirSync(dumpPath)
             .map((file) => {
             const filepath = `${dumpPath}/${file}`;
-            return { path: filepath, stat: fs.statSync(filepath) };
+            return { path: filepath, stat: node_fs_1.default.statSync(filepath) };
         })
             .filter((prop) => prop.stat.isDirectory())
             .sort((a, b) => {
@@ -164,22 +221,33 @@ class DumpGenerator {
             return a.stat.birthtime < b.stat.birthtime ? -1 : 1;
         });
         while (dumps.length >= config.history.reports) {
-            const dir = dumps.shift().path;
-            fs.rmdirSync(dir, { recursive: true });
+            const dump = dumps.shift();
+            // `shift()` answers both questions at once. It matters: a configured
+            // `history.reports` of 0 makes the condition above constant-true, and the
+            // old shape then read `.path` off undefined.
+            if (dump === undefined) {
+                break;
+            }
+            node_fs_1.default.rmSync(dump.path, { recursive: true });
         }
-        for (let i = 0; i < dumps.length - config.history.coredump; i++) {
-            const corefiles = this._listFilesMatching(path.normalize(dumps[i].path), "core");
-            if (corefiles[0]) {
-                fs.unlinkSync(corefiles[0]);
+        // The oldest dumps lose their core file, all but the `coredump` newest.
+        // The bound is clamped: `slice` counts a negative end from the end of the
+        // list, which would take core files from the dumps it has to keep.
+        const withoutCore = Math.max(0, dumps.length - config.history.coredump);
+        for (const dump of dumps.slice(0, withoutCore)) {
+            const corefiles = this._listFilesMatching(node_path_1.default.normalize(dump.path), "core");
+            const corefile = corefiles[0];
+            if (corefile) {
+                node_fs_1.default.unlinkSync(corefile);
             }
         }
     }
     _listFilesMatching(directory, start) {
-        return fs
+        return node_fs_1.default
             .readdirSync(directory)
-            .filter((entry) => fs.lstatSync(`${directory}/${entry}`).isFile() &&
+            .filter((entry) => node_fs_1.default.lstatSync(`${directory}/${entry}`).isFile() &&
             entry.startsWith(start))
-            .map((file) => path.join(directory, file));
+            .map((file) => node_path_1.default.join(directory, file));
     }
 }
 module.exports = DumpGenerator;