kuzzle 2.49.1 → 2.50.0-beta.4

package/dist/lib/kerror/codes/6-protocol.json

@@ -0,0 +1,28 @@
+{
+    "code": 6,
+    "subDomains": {
+        "runtime": {
+            "code": 1,
+            "errors": {
+                "invalid_connection": {
+                    "description": "Connection objects must have both their id and protocol set",
+                    "code": 1,
+                    "message": "Invalid connection: %s (missing id or protocol)",
+                    "class": "PluginImplementationError"
+                },
+                "unknown_connection": {
+                    "description": "The provided connection identifier is unknown",
+                    "code": 2,
+                    "message": "Unable to remove connection - unknown connection identifier: %s",
+                    "class": "PluginImplementationError"
+                },
+                "already_exists": {
+                    "description": "A protocol of the same name already exists",
+                    "code": 3,
+                    "message": "A protocol of the same name already exists: %s",
+                    "class": "PluginImplementationError"
+                }
+            }
+        }
+    }
+}

package/dist/lib/kerror/codes/7-security.json

@@ -0,0 +1,283 @@
+{
+    "code": 7,
+    "subDomains": {
+        "token": {
+            "code": 1,
+            "errors": {
+                "invalid": {
+                    "description": "Invalid authentication token.",
+                    "code": 1,
+                    "message": "Invalid token.",
+                    "class": "UnauthorizedError"
+                },
+                "unknown_user": {
+                    "description": "Missing user or missing user identifier",
+                    "code": 2,
+                    "message": "Unknown User : cannot generate token",
+                    "class": "InternalError"
+                },
+                "unknown_connection": {
+                    "description": "Missing connection identifier",
+                    "code": 3,
+                    "message": "Unknown connection : cannot generate token",
+                    "class": "InternalError"
+                },
+                "ttl_exceeded": {
+                    "description": "An authentication token was requested with a TTL larger than the configured maximum value",
+                    "code": 4,
+                    "message": "expiresIn value exceeds maximum allowed value",
+                    "class": "BadRequestError"
+                },
+                "generation_failed": {
+                    "description": "Unable to generate the requested authentication token",
+                    "code": 5,
+                    "message": "Error while generating token: %s",
+                    "class": "InternalError"
+                },
+                "expired": {
+                    "description": "The provided authentication token has expired",
+                    "code": 6,
+                    "message": "Token expired",
+                    "class": "UnauthorizedError"
+                },
+                "verification_error": {
+                    "description": "An unexpected error occured while verifying an authentication token",
+                    "code": 7,
+                    "message": "Error verifying token: %s",
+                    "class": "InternalError"
+                },
+                "refresh_forbidden": {
+                    "description": "The provided token cannot be refreshed",
+                    "code": 8,
+                    "message": "%s cannot be refreshed.",
+                    "class": "UnauthorizedError"
+                },
+                "invalid_expiration": {
+                    "description": "The specified expiration time is invalid",
+                    "code": 9,
+                    "message": "Token can not be created with this expiration time: %s",
+                    "class": "BadRequestError"
+                }
+            }
+        },
+        "credentials": {
+            "code": 2,
+            "errors": {
+                "unknown_strategy": {
+                    "description": "Unknown authentication strategy",
+                    "code": 1,
+                    "message": "Unknown authentication strategy \"%s\"",
+                    "class": "BadRequestError"
+                },
+                "database_inconsistency": {
+                    "description": "Inconsistency detected: credentials were found on a non-existing user",
+                    "code": 2,
+                    "message": "Internal database inconsistency detected: existing credentials found on non-existing user %s.",
+                    "class": "PluginImplementationError"
+                },
+                "rejected": {
+                    "description": "User's credentials were rejected during",
+                    "code": 3,
+                    "message": "Credentials rejected: %s",
+                    "class": "BadRequestError"
+                }
+            }
+        },
+        "rights": {
+            "code": 3,
+            "errors": {
+                "unauthorized": {
+                    "description": "Authentication required to execute this action",
+                    "code": 1,
+                    "message": "Unauthorized: authentication required to execute the action \"%s:%s\".",
+                    "class": "UnauthorizedError"
+                },
+                "forbidden": {
+                    "description": "Insufficient permissions to execute this action",
+                    "code": 2,
+                    "message": "Insufficient permissions to execute the action \"%s:%s\" (User \"%s\").",
+                    "class": "ForbiddenError"
+                },
+                "failsafe_mode_admin_only": {
+                    "description": "Only administrators (\"admin\" profile) can use the API in failsafe mode. Authenticate as admin or reboot without failsafe mode (\"config.plugins.common.failsafeMode\") to access the API.",
+                    "code": 3,
+                    "message": "Only administrators (\"admin\" profile) can use the API in failsafe mode.",
+                    "class": "ForbiddenError"
+                }
+            }
+        },
+        "user": {
+            "code": 4,
+            "errors": {
+                "already_exists": {
+                    "description": "Cannot create the user as it already exists",
+                    "code": 1,
+                    "message": "User %s already exists.",
+                    "class": "PreconditionError"
+                },
+                "not_found": {
+                    "description": "Attempted to access to a non-existing user",
+                    "code": 2,
+                    "message": "User \"%s\" not found.",
+                    "class": "NotFoundError"
+                },
+                "anonymous_profile_required": {
+                    "description": "The anonymous user must be assigned to the anonymous profile",
+                    "code": 3,
+                    "message": "The anonymous user must be assigned to the anonymous profile",
+                    "class": "BadRequestError"
+                },
+                "cannot_hydrate": {
+                    "description": "Database inconsistency error: a user is referencing non-existing profiles",
+                    "code": 4,
+                    "message": "Unable to hydrate the user \"%s\": missing profile(s) in the database",
+                    "class": "InternalError"
+                },
+                "uninitialized": {
+                    "description": "Attempted to access to an unitialized User object",
+                    "code": 5,
+                    "message": "Cannot get profiles for uninitialized user \"%s\"",
+                    "class": "InternalError"
+                },
+                "prevent_overwrite": {
+                    "description": "Attempted to overwrite existing users. Change \"onExistingUsers\" params to modify this method behavior.",
+                    "code": 6,
+                    "message": "Cannot overwrite existing users.",
+                    "class": "BadRequestError"
+                },
+                "no_profile": {
+                    "description": "Database inconsistency error: a user does not have profiles associated to it",
+                    "code": 7,
+                    "message": "Cannot load user \"%s\": there is no security profiles associated to it",
+                    "class": "InternalError"
+                }
+            }
+        },
+        "role": {
+            "code": 5,
+            "errors": {
+                "not_found": {
+                    "description": "Attempted to access to a non-existing role",
+                    "code": 1,
+                    "message": "Role \"%s\" not found.",
+                    "class": "NotFoundError"
+                },
+                "login_required": {
+                    "description": "Cannot remove the \"login\" action from the anonymous role",
+                    "code": 2,
+                    "message": "Cannot remove the \"login\" action from the anonymous role.",
+                    "class": "BadRequestError"
+                },
+                "cannot_delete": {
+                    "description": "Attempted to delete a base role (anonymous, default, admin)",
+                    "code": 3,
+                    "message": "The following roles are protected and cannot be deleted: anonymous, default, admin",
+                    "class": "BadRequestError"
+                },
+                "in_use": {
+                    "description": "A role still assigned to profiles cannot be deleted",
+                    "code": 4,
+                    "message": "The role \"%s\" is still used and cannot be deleted.",
+                    "class": "PreconditionError"
+                },
+                "uninitialized": {
+                    "description": "Attempted to access to an unitialized Role object",
+                    "code": 5,
+                    "message": "Cannot check permissions on the uninitialized role \"%s\"",
+                    "class": "InternalError"
+                },
+                "invalid_rights": {
+                    "description": "Invalid rights",
+                    "code": 6,
+                    "message": "Invalid rights for role \"%s\" (path: \"%s\"): %s",
+                    "class": "BadRequestError",
+                    "deprecated": "2.2.0"
+                },
+                "closure_exec_failed": {
+                    "description": "Execution failed on the provided closure",
+                    "code": 7,
+                    "message": "Invalid definition for [%s, %s]: %s",
+                    "class": "BadRequestError",
+                    "deprecated": "2.2.0"
+                },
+                "closure_missing_test": {
+                    "description": "Closures must specify a \"test\" attribute",
+                    "code": 8,
+                    "message": "Missing or malformed \"test\" attribute  for role %s (%s) : %s",
+                    "class": "BadRequestError",
+                    "deprecated": "2.2.0"
+                },
+                "unknown_controller": {
+                    "description": "Trying to set a role with a non-existing controller",
+                    "code": 9,
+                    "message": "Trying to set role %s with a non-existing controller '%s'. %s",
+                    "class": "BadRequestError"
+                },
+                "unknown_action": {
+                    "description": "Trying to set a role with a non-existing controller action",
+                    "code": 10,
+                    "message": "Trying to set role %s with a non-existing action '%s' in controller '%s'. %s",
+                    "class": "BadRequestError"
+                }
+            }
+        },
+        "profile": {
+            "code": 6,
+            "errors": {
+                "not_found": {
+                    "description": "Attempted to access to a non-existing profile",
+                    "code": 1,
+                    "message": "Profile \"%s\" not found.",
+                    "class": "NotFoundError"
+                },
+                "cannot_delete": {
+                    "description": "Attempted to delete a base profile (anonymous, default, admin)",
+                    "code": 2,
+                    "message": "The following profiles are protected and cannot be deleted: anonymous, default, admin",
+                    "class": "BadRequestError"
+                },
+                "in_use": {
+                    "description": "A profile still assigned to users cannot be deleted",
+                    "code": 3,
+                    "message": "The profile \"%s\" is still used and cannot be deleted.",
+                    "class": "PreconditionError"
+                },
+                "cannot_hydrate": {
+                    "description": "Database inconsistency error: a profile is referencing non-existing roles",
+                    "code": 4,
+                    "message": "Unable to hydrate the profile \"%s\": missing role(s) in the database",
+                    "class": "InternalError"
+                },
+                "missing_anonymous_role": {
+                    "description": "The anonymous profile must include the anonymous role",
+                    "code": 5,
+                    "message": "The anonymous profile must include the anonymous role",
+                    "class": "BadRequestError"
+                },
+                "uninitialized": {
+                    "description": "Attempted to access to an unitialized Profile object",
+                    "code": 6,
+                    "message": "Cannot get roles for uninitialized profile \"%s\"",
+                    "class": "InternalError"
+                }
+            }
+        },
+        "cookie": {
+            "code": 7,
+            "errors": {
+                "invalid": {
+                    "description": "Invalid authentication cookie.",
+                    "code": 1,
+                    "message": "Invalid cookie.",
+                    "class": "UnauthorizedError"
+                },
+                "unsupported": {
+                    "description": "Cookie authentication not supported.",
+                    "code": 2,
+                    "message": "Cookie authentication not supported.",
+                    "class": "InternalError"
+                }
+            }
+        }
+    }
+}

package/dist/lib/kerror/codes/8-cluster.json

@@ -0,0 +1,16 @@
+{
+    "code": 8,
+    "subDomains": {
+        "fatal": {
+            "code": 0,
+            "errors": {
+                "desync": {
+                    "description": "Caught a synchronization inconsistency. Triggers a suicide from the node detecting it.",
+                    "code": 1,
+                    "message": "Caught a desync error: %s.",
+                    "class": "InternalError"
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+import { ErrorDefinition } from "../../types/errors/ErrorDefinition";
+type ErrorEntry = Omit<ErrorDefinition, "description"> & {
+    description?: string;
+    deprecated?: string;
+};
+type SubDomain = {
+    code: number;
+    errors: Record<string, ErrorEntry>;
+};
+type Domain = {
+    code: number;
+    subDomains: Record<string, SubDomain>;
+};
+export type Domains = Record<string, Domain>;
+type CheckOptions = {
+    plugin?: boolean;
+};
+declare const domains: Domains;
+declare function checkDomains(errorCodesFiles: Domains, options?: CheckOptions): void;
+declare function loadPluginsErrors(pluginManifest: {
+    errors: Record<string, ErrorEntry>;
+    name: string;
+}, pluginCode: number): void;
+export { checkDomains, domains, loadPluginsErrors };

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

@@ -0,0 +1,140 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPluginsErrors = exports.domains = exports.checkDomains = void 0;
+const assert_1 = __importDefault(require("assert"));
+const errors = __importStar(require("../errors"));
+const safeObject_1 = require("../../util/safeObject");
+const _2_api_json_1 = __importDefault(require("./2-api.json"));
+const _8_cluster_json_1 = __importDefault(require("./8-cluster.json"));
+const _0_core_json_1 = __importDefault(require("./0-core.json"));
+const _3_network_json_1 = __importDefault(require("./3-network.json"));
+const _4_plugin_json_1 = __importDefault(require("./4-plugin.json"));
+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"));
+const domains = {
+    api: _2_api_json_1.default,
+    cluster: _8_cluster_json_1.default,
+    core: _0_core_json_1.default,
+    network: _3_network_json_1.default,
+    plugin: _4_plugin_json_1.default,
+    protocol: _6_protocol_json_1.default,
+    security: _7_security_json_1.default,
+    services: _1_services_json_1.default,
+    validation: _5_validation_json_1.default,
+};
+exports.domains = domains;
+function checkErrors(subdomain, domain, options) {
+    const codes = new Set();
+    for (const [name, error] of Object.entries(subdomain.errors)) {
+        (0, assert_1.default)((0, safeObject_1.has)(error, "code"), `Error configuration file : Missing required 'code' field (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`);
+        (0, assert_1.default)(Number.isInteger(error.code), `Error configuration file : Field 'code' must be an integer (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`);
+        (0, assert_1.default)(error.code > 0x0000 && error.code <= 0xffff, `Error configuration file : Field 'code' must be between 1 and 65535 (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`);
+        (0, assert_1.default)(!codes.has(error.code), `Error configuration file : code ${error.code} for error '${name}' is not unique (domain: ${domain.code}, subdomain: ${subdomain.code}).`);
+        codes.add(error.code);
+        (0, assert_1.default)((0, safeObject_1.has)(error, "message"), `Error configuration file : Missing required 'message' field (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`);
+        (0, assert_1.default)(typeof error.message === "string" && error.message.length > 0, `Error configuration file : Field 'message' must be a non-empty string (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`);
+        (0, assert_1.default)((0, safeObject_1.has)(error, "class"), `Error configuration file : Missing required 'class' field (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`);
+        (0, assert_1.default)(typeof error.class === "string", `Error configuration file : Field 'class' must be a string (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`);
+        (0, assert_1.default)((0, safeObject_1.has)(errors, error.class), `Error configuration file : Field 'class' must target a known KuzzleError object (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}), '${error.class}' does not exist.`);
+        if (!options.plugin) {
+            (0, assert_1.default)(typeof error.description === "string" && error.description.length > 0, `Error configuration file : Field 'description' must be a non-empty string (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`);
+        }
+        if (error.deprecated !== undefined && error.deprecated !== null) {
+            (0, assert_1.default)(typeof error.deprecated === "string" && error.deprecated.length > 0, `Error configuration file : Field 'deprecated' must be a non-empty string (domain: ${domain.code}, subdomain: ${subdomain.code}, error: ${name}).`);
+        }
+    }
+}
+function checkSubdomains(domain, options) {
+    const subdomainCodes = new Set();
+    for (const subdomainName of Object.keys(domain.subDomains)) {
+        const subdomain = domain.subDomains[subdomainName];
+        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}).`);
+        }
+        else if (!(0, safeObject_1.has)(subdomain, "code")) {
+            subdomain.code = 0;
+        }
+        (0, assert_1.default)(Number.isInteger(subdomain.code), `Error configuration file : Field 'code' must be an integer (domain: ${domain.code}, subdomain: ${subdomainName}).`);
+        (0, assert_1.default)(subdomain.code >= 0x00 && subdomain.code <= 0xff, `Error configuration file : Field 'code' must be between 0 and 255 (domain: ${domain.code}, subdomain: ${subdomainName}).`);
+        (0, assert_1.default)(!subdomainCodes.has(subdomain.code), `Error configuration file : code ${subdomain.code} for subdomain '${subdomainName}' is not unique (domain: ${domain.code}).`);
+        if (!options.plugin || subdomain.code > 0) {
+            subdomainCodes.add(subdomain.code);
+        }
+        (0, assert_1.default)((0, safeObject_1.has)(subdomain, "errors"), `Error configuration file : Missing required 'errors' field (domain: ${domain.code}, subdomain: ${subdomainName}).`);
+        (0, assert_1.default)((0, safeObject_1.isPlainObject)(subdomain.errors), `Error configuration file : Field 'errors' must be an object (domain: ${domain.code}, subdomain: ${subdomainName}).`);
+        checkErrors(subdomain, domain, options);
+    }
+}
+function checkDomains(errorCodesFiles, options = { plugin: false }) {
+    const domainCodes = new Set();
+    for (const domainName of Object.keys(errorCodesFiles)) {
+        const domain = errorCodesFiles[domainName];
+        (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}').`);
+        (0, assert_1.default)(!domainCodes.has(domain.code), `Error configuration file : code ${domain.code} for domain ${domainName} is not unique.`);
+        domainCodes.add(domain.code);
+        (0, assert_1.default)((0, safeObject_1.has)(domain, "subDomains"), `Error configuration file : Missing required 'subDomains' field. (domain: '${domainName}').`);
+        (0, assert_1.default)((0, safeObject_1.isPlainObject)(domain.subDomains), `Error configuration file : Field 'subDomains' must be an object. (domain: '${domainName}').`);
+        checkSubdomains(domain, options);
+    }
+}
+exports.checkDomains = checkDomains;
+function loadPluginsErrors(pluginManifest, pluginCode) {
+    domains.plugin.subDomains[pluginManifest.name] = {
+        code: pluginCode,
+        errors: pluginManifest.errors,
+    };
+    checkDomains({ plugin: domains.plugin }, { plugin: true });
+}
+exports.loadPluginsErrors = loadPluginsErrors;
+checkDomains(domains);
+//# sourceMappingURL=index.js.map

package/{lib → 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 { ErrorDomains } from "../types";
 /**
  * Construct and return the corresponding error
  *
@@ -11,7 +11,7 @@ import { ErrorDomains } from "../types";
  * @param  placeholders - Placeholders value to inject in error message
  * @param  options - Last param can be additional options { message }
  */
-export declare function rawGet(domains: ErrorDomains, domain: string, subdomain: string, error: string, ...placeholders: any[]): KuzzleError;
+export declare function rawGet(domains: Domains, domain: string, subdomain: string, error: string, ...placeholders: any[]): KuzzleError;
 /**
  * Returns a promise rejected with the corresponding error
  *
@@ -21,7 +21,7 @@ export declare function rawGet(domains: ErrorDomains, domain: string, subdomain:
  * @param  error - Error name: (eg: 'index_not_found')
  * @param  placeholders - Placeholders value to inject in error message
  */
-export declare function rawReject(domains: ErrorDomains, domain: string, subdomain: string, error: string, ...placeholders: any[]): Promise<any>;
+export declare function rawReject(domains: Domains, domain: string, subdomain: string, error: string, ...placeholders: any[]): Promise<any>;
 /**
  * Construct and return the corresponding error, with its stack
  * trace derivated from a provided source error
@@ -33,11 +33,11 @@ export declare function rawReject(domains: ErrorDomains, domain: string, subdoma
  * @param  error - Error name: (eg: 'index_not_found')
  * @param  placeholders - Placeholders value to inject in error message
  */
-export declare function rawGetFrom(domains: ErrorDomains, source: Error, domain: string, subdomain: string, error: string, ...placeholders: any[]): KuzzleError;
+export declare function rawGetFrom(domains: Domains, source: Error, domain: string, subdomain: string, error: string, ...placeholders: any[]): KuzzleError;
 /**
  * Wrap error functions with the provided domain and subdomain.
  */
-export declare function rawWrap(domains: ErrorDomains, domain: string, subdomain: string): {
+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>;

package/{lib → dist/lib}/kuzzle/Logger.d.ts

@@ -4,6 +4,11 @@ import { KuzzleConfiguration } from "../../";
  * The Logger class provides logging functionality for Kuzzle.
  */
 export declare class Logger extends KuzzleLogger {
+    /**
+     * Shared pino instance to avoid spawning a transport worker for every
+     * Logger instance (pino.transport adds a process "exit" listener).
+     */
+    private static basePino;
     private warnedForSillyDeprecation;
     private warnedForVerboseDeprecation;
     constructor(kuzzleConfig: KuzzleConfiguration, namespace?: string);
@@ -23,4 +28,5 @@ export declare class Logger extends KuzzleLogger {
     verbose(message: string): void;
     getLevel(): string;
     setLevel(level: string): void;
+    child(namespace: string): Logger;
 }

package/{lib → dist/lib}/kuzzle/Logger.js

@@ -46,8 +46,13 @@ class Logger extends kuzzle_logger_1.KuzzleLogger {
             }
             return mergingObject;
         };
-        super(deprecatedConfig?.services
-            ? {
+        const hasSharedPino = Logger.basePino !== undefined;
+        let loggerConfig;
+        if (hasSharedPino) {
+            loggerConfig = { getMergingObject, skipPinoInstance: true };
+        }
+        else if (deprecatedConfig?.services) {
+            loggerConfig = {
                 getMergingObject,
                 serviceName: "kuzzle",
                 transport: {
@@ -67,13 +72,25 @@ class Logger extends kuzzle_logger_1.KuzzleLogger {
                         }
                     }),
                 },
-            }
-            : {
+            };
+        }
+        else {
+            loggerConfig = {
                 ...config,
                 getMergingObject,
-            });
+            };
+        }
+        super(loggerConfig);
         this.warnedForSillyDeprecation = false;
         this.warnedForVerboseDeprecation = false;
+        if (hasSharedPino) {
+            // Reuse the shared pino instance to avoid stacking process exit listeners
+            // added by pino.transport when spawning its worker thread.
+            this.pino = Logger.basePino.child({});
+        }
+        else {
+            Logger.basePino = this.pino;
+        }
         if (deprecatedConfig) {
             this.warn("[DEPRECATED] The plugins.kuzzle-plugin-logger configuration is deprecated, use server.logs instead.");
         }
@@ -110,6 +127,10 @@ class Logger extends kuzzle_logger_1.KuzzleLogger {
     setLevel(level) {
         this.level = level;
     }
+    child(namespace) {
+        // TODO, this is fishy we will probably need to properly remove the "as Logger"
+        return super.child(namespace);
+    }
 }
 exports.Logger = Logger;
 //# sourceMappingURL=Logger.js.map

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

@@ -0,0 +1,14 @@
+export = DumpGenerator;
+declare class DumpGenerator {
+    _dump: boolean;
+    logger: import("./Logger").Logger;
+    /**
+     * Create a dump
+     *
+     * @param {string} suffix
+     * @returns {Promise}
+     */
+    dump(suffix: string): Promise<any>;
+    _cleanUpHistory(): void;
+    _listFilesMatching(directory: any, start: any): string[];
+}