kuzzle 2.56.0 → 2.57.0-beta.2

package/dist/lib/core/validation/validationUtils.d.ts

@@ -0,0 +1,31 @@
+import type { CuratedFieldSpecification, ErrorMessages, RawSpecification, StructuredFieldSpecification, VerboseErrorMessages } from "./specification";
+/**
+ * Narrows `object` to a plain object holding none but the allowed properties.
+ */
+export declare function checkAllowedProperties(object: unknown, allowedProperties: string[]): object is Record<string, unknown>;
+/**
+ * Assembles curated fields, grouped by depth, into the tree the validator
+ * walks. Depth counting starts at 1.
+ *
+ * @throws {PreconditionError}
+ */
+export declare function curateStructuredFields(typeAllowsChildren: string[], fields: Record<number, CuratedFieldSpecification[]>, maxDepth: number): StructuredFieldSpecification;
+/**
+ * Walks a field's path down the tree and answers the node that must hold it.
+ *
+ * @throws {PreconditionError} when an intermediate node is missing
+ */
+export declare function getParent(structuredFields: StructuredFieldSpecification, fieldPath: string[]): StructuredFieldSpecification;
+/**
+ * Files a validation message, or throws it.
+ *
+ * When `structured` holds, the message is hung off `errorHolder` at the field's
+ * own path so the caller can report it in place; when it does not, the first
+ * message throws and the holder is never written to.
+ *
+ * @throws {BadRequestError} when `structured` is false
+ */
+export declare function storeErrorMessage(errorContext: string | string[], errorHolder: VerboseErrorMessages, message: string): void;
+export declare function throwErrorMessage(errorContext: string | string[], message: string): never;
+export declare function manageErrorMessage(errorContext: string | string[], errorHolder: ErrorMessages, message: string, structured: boolean): void;
+export declare function getValidationConfiguration(): Promise<RawSpecification>;

package/dist/lib/core/validation/validationUtils.js

@@ -0,0 +1,190 @@
+"use strict";
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2022 Kuzzle
+ * mailto: support AT kuzzle.io
+ * website: http://kuzzle.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValidationConfiguration = exports.manageErrorMessage = exports.throwErrorMessage = exports.storeErrorMessage = exports.getParent = exports.curateStructuredFields = exports.checkAllowedProperties = void 0;
+const kerror = __importStar(require("../../kerror"));
+const safeObject_1 = require("../../util/safeObject");
+const specification_1 = require("./specification");
+const assertionError = kerror.wrap("validation", "assert");
+/**
+ * Narrows `object` to a plain object holding none but the allowed properties.
+ */
+function checkAllowedProperties(object, allowedProperties) {
+    if (!(0, safeObject_1.isPlainObject)(object)) {
+        return false;
+    }
+    return !Object.keys(object).some((propertyName) => !allowedProperties.includes(propertyName));
+}
+exports.checkAllowedProperties = checkAllowedProperties;
+/**
+ * Assembles curated fields, grouped by depth, into the tree the validator
+ * walks. Depth counting starts at 1.
+ *
+ * @throws {PreconditionError}
+ */
+function curateStructuredFields(typeAllowsChildren, fields, maxDepth) {
+    const structuredFields = {
+        children: {},
+        root: true,
+    };
+    for (let i = 1; i <= maxDepth; i++) {
+        const sameDepth = fields[i];
+        if (sameDepth === undefined) {
+            throw assertionError.get("missing_nested_spec");
+        }
+        sameDepth.forEach((field) => {
+            const parent = getParent(structuredFields, field.path), 
+            // `path` is a field's key split on "/", so it always has a last
+            // segment; the fallback is what makes that readable to the compiler.
+            childKey = field.path.at(-1) ?? "";
+            if (!parent.root && !typeAllowsChildren.includes(parent.type ?? "")) {
+                throw assertionError.get("unexpected_children", parent.type);
+            }
+            const children = (parent.children ?? (parent.children = {}));
+            children[childKey] = field;
+        });
+    }
+    return structuredFields;
+}
+exports.curateStructuredFields = curateStructuredFields;
+/**
+ * Walks a field's path down the tree and answers the node that must hold it.
+ *
+ * @throws {PreconditionError} when an intermediate node is missing
+ */
+function getParent(structuredFields, fieldPath) {
+    if (fieldPath.length === 1) {
+        return structuredFields;
+    }
+    let pointer = structuredFields;
+    for (const segment of fieldPath.slice(0, -1)) {
+        const child = pointer.children?.[segment];
+        if (child === undefined) {
+            throw assertionError.get("missing_parent", fieldPath.join("."));
+        }
+        pointer = child;
+    }
+    return pointer;
+}
+exports.getParent = getParent;
+/**
+ * Files a validation message, or throws it.
+ *
+ * When `structured` holds, the message is hung off `errorHolder` at the field's
+ * own path so the caller can report it in place; when it does not, the first
+ * message throws and the holder is never written to.
+ *
+ * @throws {BadRequestError} when `structured` is false
+ */
+function storeErrorMessage(errorContext, errorHolder, message) {
+    if (errorContext === "document") {
+        const documentScope = (errorHolder.documentScope ?? (errorHolder.documentScope = []));
+        documentScope.push(message);
+        return;
+    }
+    let pointer = (errorHolder.fieldScope ?? (errorHolder.fieldScope = {}));
+    for (const segment of errorContext) {
+        const children = (pointer.children ?? (pointer.children = {}));
+        pointer = children[segment] ?? (children[segment] = {});
+    }
+    const messages = (pointer.messages ?? (pointer.messages = []));
+    messages.push(message);
+}
+exports.storeErrorMessage = storeErrorMessage;
+function throwErrorMessage(errorContext, message) {
+    if (errorContext === "document") {
+        throw kerror.get("validation", "check", "failed_document", message);
+    }
+    // Everything that is not the "document" literal is a field path.
+    throw kerror.get("validation", "check", "failed_field", Array.isArray(errorContext) ? errorContext.join(".") : errorContext, message);
+}
+exports.throwErrorMessage = throwErrorMessage;
+function manageErrorMessage(errorContext, errorHolder, message, structured) {
+    if (!structured) {
+        throwErrorMessage(errorContext, message);
+    }
+    // `structured` and the holder's shape are the same fact: `validate` builds an
+    // object exactly when `verbose` holds, and a list when it does not. The
+    // narrowing is what says so; the branch cannot be taken.
+    if (Array.isArray(errorHolder)) {
+        return;
+    }
+    storeErrorMessage(errorContext, errorHolder, message);
+}
+exports.manageErrorMessage = manageErrorMessage;
+/**
+ * Reads every stored specification, falling back to the one in the
+ * configuration when the internal index holds none — the database is not
+ * necessarily prepared yet when this first runs.
+ */
+function collectStoredSpecification(validation, hit) {
+    var _a;
+    const { _id, _source } = hit;
+    const collectionName = `${_id.split("#")[0]}/${_id.split("#")[1]}`;
+    for (const required of ["index", "collection", "validation"]) {
+        if (!(0, safeObject_1.get)(_source, required)) {
+            throw assertionError.get("incorrect_validation_format", collectionName, required);
+        }
+    }
+    const indexValidation = (validation[_a = _source.index] ?? (validation[_a] = {}));
+    indexValidation[_source.collection] = _source.validation;
+}
+function getValidationConfiguration() {
+    return global.kuzzle.internalIndex
+        .search("validations", {}, { from: 0, size: 1000 })
+        .then((result) => {
+        if (!result || !Array.isArray(result.hits) || result.hits.length === 0) {
+            // We can't wait prepareDb as it runs outside of the rest of the start
+            return (0, specification_1.configuredSpecifications)() || {};
+        }
+        const validation = {};
+        for (const hit of result.hits) {
+            collectStoredSpecification(validation, hit);
+        }
+        return validation;
+    });
+}
+exports.getValidationConfiguration = getValidationConfiguration;
+//# sourceMappingURL=validationUtils.js.map

package/dist/lib/kerror/codes/4-plugin.json

@@ -93,12 +93,6 @@
                     "code": 15,
                     "message": "Plugin \"%s\" not found.%s",
                     "class": "NotFoundError"
-                },
-                "invalid_openapi_schema": {
-                    "description": "OpenAPI specification is invalid",
-                    "code": 16,
-                    "message": "Invalid OpenAPI specification: \"%s\"",
-                    "class": "PluginImplementationError"
                 }
             }
         },
@@ -349,12 +343,6 @@
                     "code": 9,
                     "message": "Unexpected return value from action \"%s:%s\": expected a Promise",
                     "class": "PluginImplementationError"
-                },
-                "invalid_openapi_schema": {
-                    "description": "OpenAPI specification is invalid",
-                    "code": 10,
-                    "message": "Invalid OpenAPI specification in \"%s:%s\", %s : %s",
-                    "class": "PluginImplementationError"
                 }
             }
         },

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

@@ -1,4 +1,4 @@
-import { ErrorDefinition } from "../../types/errors/ErrorDefinition";
+import type { ErrorDefinition } from "../../types/errors/ErrorDefinition";
 type ErrorEntry = Omit<ErrorDefinition, "description"> & {
     description?: string;
     deprecated?: string;
@@ -15,7 +15,17 @@ export type Domains = Record<string, Domain>;
 type CheckOptions = {
     plugin?: boolean;
 };
-declare const domains: Domains;
+declare const domains: {
+    api: Domain;
+    cluster: Domain;
+    core: Domain;
+    network: Domain;
+    plugin: Domain;
+    protocol: Domain;
+    security: Domain;
+    services: Domain;
+    validation: Domain;
+};
 declare function checkDomains(errorCodesFiles: Domains, options?: CheckOptions): void;
 declare function loadPluginsErrors(pluginManifest: {
     errors: Record<string, ErrorEntry>;

package/dist/lib/kerror/codes/index.js

@@ -59,6 +59,9 @@ const _6_protocol_json_1 = __importDefault(require("./6-protocol.json"));
 const _7_security_json_1 = __importDefault(require("./7-security.json"));
 const _1_services_json_1 = __importDefault(require("./1-services.json"));
 const _5_validation_json_1 = __importDefault(require("./5-validation.json"));
+// `satisfies`, not an annotation: the nine domains are known, and
+// `loadPluginsErrors` reaches into `domains.plugin` — which, through a
+// `Record<string, Domain>`, is `Domain | undefined`.
 const domains = {
     api: _2_api_json_1.default,
     cluster: _8_cluster_json_1.default,
@@ -94,8 +97,7 @@ function checkErrors(subdomain, domain, options) {
 }
 function checkSubdomains(domain, options) {
     const subdomainCodes = new Set();
-    for (const subdomainName of Object.keys(domain.subDomains)) {
-        const subdomain = domain.subDomains[subdomainName];
+    for (const [subdomainName, subdomain] of Object.entries(domain.subDomains)) {
         if (!options.plugin) {
             (0, assert_1.default)((0, safeObject_1.has)(subdomain, "code"), `Error configuration file : Missing required 'code' field (domain: ${domain.code}, subdomain: ${subdomainName}).`);
         }
@@ -115,8 +117,7 @@ function checkSubdomains(domain, options) {
 }
 function checkDomains(errorCodesFiles, options = { plugin: false }) {
     const domainCodes = new Set();
-    for (const domainName of Object.keys(errorCodesFiles)) {
-        const domain = errorCodesFiles[domainName];
+    for (const [domainName, domain] of Object.entries(errorCodesFiles)) {
         (0, assert_1.default)((0, safeObject_1.has)(domain, "code"), `Error configuration file : Missing required 'code' field. (domain: '${domainName}').`);
         (0, assert_1.default)(Number.isInteger(domain.code), `Error configuration file : Field 'code' must be an integer. (domain: '${domainName}').`);
         (0, assert_1.default)(domain.code >= 0x00 && domain.code <= 0xff, `Error configuration file : Field 'code' must be between 0 and 255. (domain: '${domainName}').`);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-import { JSONObject } from "kuzzle-sdk";
+import type { JSONObject } from "../../types/JSONObject";
 /**
  * API error are instances of this class.
  * See https://docs.kuzzle.io/core/2/api/errors/types/
@@ -11,17 +11,46 @@ export declare class KuzzleError extends Error {
     /**
      * Error unique code
      * @see https://docs.kuzzle.io/core/2/api/errors/error-codes/
+     *
+     * Set on every error built from the code registry (`kerror`), which is how
+     * Kuzzle builds its own; undefined on an error built by hand
+     * (`new BadRequestError("...")`), which plugins and Kuzzle itself also do.
+     * Declared as always present all the same, because that is what v2.56.0
+     * declared and what code compiled against it reads. See the constructor.
      */
     code: number;
     /**
      * Error unique identifier
+     *
+     * Undefined under the same conditions as {@link code}, and declared as
+     * always present for the same reason.
      */
     id: string;
     /**
-     * Placeholders used to construct the error message.
+     * The placeholders that were substituted into the message, when `kerror`
+     * built the error; undefined otherwise. `kerror.get` takes them from its
+     * caller, which may hand it anything — an id, a count, the value that
+     * failed a type check — but `string[]` is what v2.56.0 declared, and code
+     * compiled against it assigns this to a `string[]`.
      */
     props: string[];
-    constructor(message: string, status: number, id?: string, code?: number);
+    /**
+     * The arguments are not narrowed to what they are meant to be (a string or
+     * an `Error`, a string id, a numeric code): v2.56.0's subclasses took
+     * untyped ones, so `new InternalError(caught)` with a `catch` variable of
+     * type `unknown` compiled, and must still.
+     *
+     * A `message` that is not an `Error` is handed to `Error`, which
+     * stringifies it; `undefined` and `null` give an empty one —
+     * `doc/build-error-codes.js` constructs one of each class with no arguments
+     * just to read its `status`.
+     *
+     * @param message - a string, or an `Error` whose message and stack are kept
+     * @param status - HTTP status code
+     * @param id - error unique identifier (a string)
+     * @param code - error unique code (a number)
+     */
+    constructor(message: unknown, status: number, id?: unknown, code?: unknown);
     /**
      * Error class name (e.g: 'NotFoundError')
      */

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

@@ -45,24 +45,38 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KuzzleError = void 0;
 const util = __importStar(require("util"));
+/**
+ * `util.types.isNativeError` rather than `instanceof Error`: it answers true
+ * for an error built in another realm, which `instanceof` does not, and false
+ * for an object that merely has `Error.prototype`. Node deprecates it in
+ * favour of `Error.isError`, which needs Node 24 while this package supports
+ * `>=20` — hence the NOSONAR. Revisit when the floor moves.
+ */
+function isError(value) {
+    return util.types.isNativeError(value); // NOSONAR
+}
 /**
  * API error are instances of this class.
  * See https://docs.kuzzle.io/core/2/api/errors/types/
  */
 class KuzzleError extends Error {
+    /**
+     * The implementation names what `message` is meant to be; the public
+     * signature above is what it may be. Anything else goes straight to
+     * `Error`'s own conversion.
+     */
     constructor(message, status, id, code) {
-        super(message);
+        super(isError(message) ? message.message : (message ?? ""));
         this.status = status;
-        this.code = code;
-        this.id = id;
-        this.props = undefined;
+        // The three fields declared above as always present, stored as handed:
+        // their declarations are the ones code compiled against v2.56.0 reads,
+        // not a description of every value that reaches this line.
+        Object.assign(this, { code, id, props: undefined });
         this.stack = undefined;
-        if (util.types.isNativeError(message)) {
-            this.message = message.message;
+        if (isError(message)) {
             this.stack = message.stack;
         }
         else {
-            this.message = message;
             Error.captureStackTrace(this, KuzzleError);
         }
     }

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

@@ -2,6 +2,6 @@ import { KuzzleError } from "./kuzzleError";
 export declare class MultipleErrorsError extends KuzzleError {
     errors: Array<KuzzleError>;
     count: number;
-    constructor(message: string, errors?: KuzzleError[], id?: string, code?: number);
-    toJSON(): import("kuzzle-sdk").JSONObject;
+    constructor(message?: string, errors?: KuzzleError[], id?: string, code?: number);
+    toJSON(): import("../../..").JSONObject;
 }

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

@@ -23,7 +23,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MultipleErrorsError = void 0;
 const kuzzleError_1 = require("./kuzzleError");
 class MultipleErrorsError extends kuzzleError_1.KuzzleError {
-    constructor(message, errors = [], id, code) {
+    constructor(message = "", errors = [], id, code) {
         super(message, 400, id, code);
         this.errors = errors;
         this.count = errors.length;
@@ -34,7 +34,7 @@ class MultipleErrorsError extends kuzzleError_1.KuzzleError {
         try {
             serialized.errors = this.errors.map((error) => error.toJSON());
         }
-        catch (error) {
+        catch {
             serialized.errors = this.errors;
         }
         return serialized;

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

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

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

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

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

@@ -2,6 +2,12 @@ import { KuzzleError } from "./kuzzleError";
 export declare class PartialError extends KuzzleError {
     errors: Array<KuzzleError>;
     count: number;
-    constructor(message: any, body: any, id: any, code: any);
-    toJSON(): import("kuzzle-sdk").JSONObject;
+    constructor(message?: string | Error, id?: string, code?: number);
+    constructor(message?: string | Error, body?: KuzzleError[], id?: string, code?: number);
+    /**
+     * v2.56.0 declared all four arguments untyped: a body that is not a list of
+     * `KuzzleError` (`[{ _id, reason }]`, `Error[]`) compiled, and must still.
+     */
+    constructor(message?: unknown, body?: unknown, id?: unknown, code?: unknown);
+    toJSON(): import("../../..").JSONObject;
 }

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

@@ -23,18 +23,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PartialError = void 0;
 const kuzzleError_1 = require("./kuzzleError");
 class PartialError extends kuzzleError_1.KuzzleError {
-    constructor(message, body, id, code) {
+    /**
+     * Two call shapes, both public API: the documented one carries the partial
+     * errors — `(message, body, id, code)` — and the one `kerror` uses for every
+     * other error class — `(message, id, code)`. They are told apart the way
+     * they always were: a numeric third argument with no fourth means the
+     * arguments are shifted by one.
+     */
+    constructor(message = "", body, id, code) {
+        let errors = [];
+        let errorId;
+        let errorCode;
         if (code === undefined && typeof id === "number") {
-            code = id;
-            id = body;
-            body = [];
+            errorCode = id;
+            errorId = typeof body === "string" ? body : undefined;
         }
-        else if (body === undefined) {
-            body = [];
+        else {
+            errorId = typeof id === "string" ? id : undefined;
+            errorCode = code;
+            if (Array.isArray(body)) {
+                errors = body;
+            }
         }
-        super(message, 206, id, code);
-        this.errors = body;
-        this.count = body.length;
+        super(message, 206, errorId, errorCode);
+        this.errors = errors;
+        this.count = errors.length;
     }
     toJSON() {
         const serialized = super.toJSON();

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

@@ -1,4 +1,12 @@
 import { KuzzleError } from "./kuzzleError";
+/**
+ * An error in plugin or application code, as opposed to Kuzzle's own.
+ *
+ * Its message used to end with "This is probably not a Kuzzle error, but a
+ * problem with a plugin implementation." on every one of the ~80 ids of this
+ * class: it said nothing the id (`plugin.*`) does not, and it came between the
+ * message and the stack of the error that actually happened.
+ */
 export declare class PluginImplementationError extends KuzzleError {
-    constructor(message: any, id?: any, code?: any);
+    constructor(message?: unknown, id?: unknown, code?: unknown);
 }

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

@@ -22,11 +22,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PluginImplementationError = void 0;
 const kuzzleError_1 = require("./kuzzleError");
+/**
+ * An error in plugin or application code, as opposed to Kuzzle's own.
+ *
+ * Its message used to end with "This is probably not a Kuzzle error, but a
+ * problem with a plugin implementation." on every one of the ~80 ids of this
+ * class: it said nothing the id (`plugin.*`) does not, and it came between the
+ * message and the stack of the error that actually happened.
+ */
 class PluginImplementationError extends kuzzleError_1.KuzzleError {
-    constructor(message, id, code) {
+    constructor(message = "", id, code) {
         super(message, 500, id, code);
-        this.message +=
-            "\nThis is probably not a Kuzzle error, but a problem with a plugin implementation.";
     }
 }
 exports.PluginImplementationError = PluginImplementationError;

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

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

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

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