kuzzle 2.49.1 → 2.50.0-beta.4

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

@@ -0,0 +1,5 @@
+/**
+ * Loads, interprets and checks configuration files
+ * @returns {object}
+ */
+export declare function loadConfig(): any;

package/dist/lib/config/index.js

@@ -0,0 +1,244 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = void 0;
+const assert_1 = __importDefault(require("assert"));
+const rc_1 = __importDefault(require("rc"));
+const default_config_1 = __importDefault(require("./default.config"));
+const package_json_1 = __importDefault(require("../../package.json"));
+const kerror_1 = require("../kerror");
+const safeObject_1 = require("../util/safeObject");
+const bytes_1 = __importDefault(require("../util/bytes"));
+const wrapped = (0, kerror_1.wrap)("core", "configuration");
+/**
+ * Loads, interprets and checks configuration files
+ * @returns {object}
+ */
+function loadConfig() {
+    let config;
+    try {
+        config = (0, rc_1.default)("kuzzle", default_config_1.default);
+    }
+    catch (e) {
+        throw wrapped.get("cannot_parse", e.message);
+    }
+    config = unstringify(config);
+    checkLimitsConfig(config);
+    checkHttpOptions(config);
+    checkWebSocketOptions(config);
+    checkClusterOptions(config);
+    config.internal = {
+        hash: {
+            seed: Buffer.from("^m&mOISKBvb1xpl1mRsrylaQXpjb&IJX"),
+        },
+    };
+    preprocessHttpOptions(config);
+    preprocessProtocolsOptions(config);
+    preprocessRedisOptions(config.services.internalCache);
+    preprocessRedisOptions(config.services.memoryStorage);
+    // Injects the current Kuzzle version
+    config.version = package_json_1.default.version;
+    return config;
+}
+exports.loadConfig = loadConfig;
+/**
+ * RC params can be overriden using environment variables,
+ * in which case all values are passed as strings.
+ *
+ * When dealing with configuration, we can safely assume the expected
+ * correct type
+ *
+ * @param {object} cfg - configuration loaded using RC
+ * @returns {object} correctly typed configuration
+ */
+function unstringify(cfg) {
+    Object.keys(cfg)
+        .filter((k) => !/version$/i.test(k) &&
+        (typeof cfg[k] === "string" || cfg[k] instanceof Object))
+        .forEach((k) => {
+        if (typeof cfg[k] === "string") {
+            if (cfg[k] === "true") {
+                cfg[k] = true;
+            }
+            else if (cfg[k] === "false") {
+                cfg[k] = false;
+            }
+            else if (cfg[k].startsWith("*json:")) {
+                try {
+                    cfg[k] = JSON.parse(cfg[k].replace(/^\*json:/, ""));
+                }
+                catch (e) {
+                    throw wrapped.get("cannot_parse", `the key "${k}" does not contain a valid stringified JSON (${cfg[k]})`);
+                }
+            }
+            else if (/^(-|\+)?([0-9]+)$/.test(cfg[k])) {
+                cfg[k] = Number.parseInt(cfg[k]);
+            }
+            else if (/^(-|\+)?([0-9]+(\.[0-9]+)?)$/.test(cfg[k])) {
+                cfg[k] = parseFloat(cfg[k]);
+            }
+        }
+        else {
+            cfg[k] = unstringify(cfg[k]);
+        }
+    });
+    return cfg;
+}
+/**
+ * Checks the "limits" section of the provided configuration object.
+ * Throw warnings if invalid configuration are detected and auto-correct
+ * them if necessary
+ *
+ * @param {object} cfg
+ */
+function checkLimitsConfig(cfg) {
+    const limits = [
+        "concurrentRequests",
+        "documentsFetchCount",
+        "documentsWriteCount",
+        "loginsPerSecond",
+        "requestsBufferSize",
+        "requestsBufferWarningThreshold",
+        "subscriptionConditionsCount",
+        "subscriptionMinterms",
+        "subscriptionRooms",
+        "subscriptionDocumentTTL",
+    ];
+    const canBeZero = [
+        "subscriptionMinterms",
+        "subscriptionRooms",
+        "subscriptionDocumentTTL",
+    ];
+    if (!(0, safeObject_1.isPlainObject)(cfg.limits)) {
+        throw wrapped.get("invalid_type", "limits", "object");
+    }
+    for (const opt of limits) {
+        if (typeof cfg.limits[opt] !== "number") {
+            throw wrapped.get("invalid_type", `limits.${opt}`, "number");
+        }
+        if (cfg.limits[opt] < 0 ||
+            (cfg.limits[opt] === 0 && !canBeZero.includes(opt))) {
+            const allowed = `>= ${canBeZero.includes(opt) ? "0" : "1"}`;
+            throw wrapped.get("out_of_range", `limits.${opt}`, allowed);
+        }
+    }
+    if (cfg.limits.concurrentRequests >= cfg.limits.requestsBufferSize) {
+        throw wrapped.get("out_of_range", "limits.concurrentRequests", 'lower than "limits.requestsBufferSize"');
+    }
+    if (cfg.limits.requestsBufferWarningThreshold < cfg.limits.concurrentRequests ||
+        cfg.limits.requestsBufferWarningThreshold > cfg.limits.requestsBufferSize) {
+        throw wrapped.get("out_of_range", "limits.requestsBufferWarningThreshold", "[limits.concurrentRequests, limits.requestsBufferSize]");
+    }
+}
+function checkWebSocketOptions(config) {
+    const cfg = config.server.protocols.websocket;
+    if (cfg === undefined) {
+        return;
+    }
+    (0, assert_1.default)(typeof cfg.enabled === "boolean", `[websocket] "enabled" parameter: invalid value "${cfg.enabled}" (boolean expected)`);
+    (0, assert_1.default)(Number.isInteger(cfg.idleTimeout) && cfg.idleTimeout >= 0, `[websocket] "idleTimeout" parameter: invalid value "${cfg.idleTimeout}" (integer >= 1000 expected)`);
+    (0, assert_1.default)(Number.isInteger(cfg.rateLimit) && cfg.rateLimit >= 0, `[websocket] "rateLimit" parameter: invalid value "${cfg.rateLimit}" (integer >= 0 expected)`);
+    (0, assert_1.default)(typeof cfg.compression === "boolean", `[websocket] "compression" parameter: invalid value "${cfg.compression}" (boolean expected)`);
+    (0, assert_1.default)(typeof cfg.sendPingsAutomatically === "boolean", `[websocket] "sendPingsAutomatically" parameter: invalid value "${cfg.sendPingsAutomatically}" (boolean expected)`);
+    (0, assert_1.default)(typeof cfg.resetIdleTimeoutOnSend === "boolean", `[websocket] "resetIdleTimeoutOnSend" parameter: invalid value "${cfg.resetIdleTimeoutOnSend}" (boolean expected)`);
+}
+function checkHttpOptions(config) {
+    const cfg = config.server.protocols.http;
+    if (cfg === undefined) {
+        return;
+    }
+    (0, assert_1.default)(typeof config.http.accessControlAllowOrigin === "string" ||
+        Array.isArray(config.http.accessControlAllowOrigin), `[http] "accessControlAllowOrigin" parameter: invalid value "${config.http.accessControlAllowOrigin}" (array or string expected)`);
+    (0, assert_1.default)(typeof config.http.accessControlAllowOriginUseRegExp === "boolean", `[http] "accessControlAllowOriginUseRegExp" parameter: invalid value "${cfg.accessControlAllowOriginUseRegExp}" (boolean expected)`);
+    (0, assert_1.default)(typeof cfg.enabled === "boolean", `[http] "enabled" parameter: invalid value "${cfg.enabled}" (boolean expected)`);
+    (0, assert_1.default)(typeof cfg.allowCompression === "boolean", `[http] "allowCompression" parameter: invalid value "${cfg.allowCompression}" (boolean expected)`);
+    (0, assert_1.default)(Number.isInteger(cfg.maxEncodingLayers) && cfg.maxEncodingLayers >= 1, `[http] "maxEncodingLayers" parameter: invalid value "${cfg.maxEncodingLayers}" (integer >= 1 expected)`);
+    const maxFormFileSize = (0, bytes_1.default)(cfg.maxFormFileSize);
+    (0, assert_1.default)(Number.isInteger(maxFormFileSize) && maxFormFileSize >= 0, `[http] "maxFormFileSize" parameter: cannot parse "${cfg.maxFormFileSize}"`);
+    cfg.maxFormFileSize = maxFormFileSize;
+    (0, assert_1.default)(typeof config.http.cookieAuthentication === "boolean", `[http] "cookieAuthentication" parameter: invalid value "${config.http.cookieAuthentication}" (boolean expected)`);
+    (0, assert_1.default)(Array.isArray(cfg.additionalContentTypes) &&
+        cfg.additionalContentTypes.every((ct) => typeof ct === "string"), `[http] "additionalContentTypes" parameter: invalid value "${cfg.additionalContentTypes}" (array of strings expected)`);
+}
+function checkClusterOptions(config) {
+    const cfg = config.cluster;
+    for (const prop of [
+        "heartbeat",
+        "joinTimeout",
+        "minimumNodes",
+        "activityDepth",
+        "syncTimeout",
+    ]) {
+        (0, assert_1.default)(typeof cfg[prop] === "number" && cfg[prop] > 0, `[CONFIG] kuzzlerc.cluster.${prop}: value must be a number greater than 0`);
+    }
+    (0, assert_1.default)(cfg.syncTimeout < cfg.joinTimeout, "[CONFIG] kuzzlerc.cluster.syncTimeout: value must be lower than kuzzlerc.cluster.joinTimeout");
+    for (const prop of ["command", "sync"]) {
+        (0, assert_1.default)(typeof cfg.ports[prop] === "number" && cfg.ports[prop] > 0, `[CONFIG] kuzzlerc.cluster.ports.${prop}: value must be a number greater than 0`);
+    }
+    (0, assert_1.default)(typeof cfg.ipv6 === "boolean", "[CONFIG] kuzzlerc.cluster.ipv6: boolean expected");
+    // If config is passed with env variable, ip cannot be the value null
+    // but only blank string or the string "null"
+    if (`${cfg.ip}`.length === 0 || cfg.ip === "null") {
+        cfg.ip = null;
+    }
+    (0, assert_1.default)(!cfg.ip || ["private", "public"].includes(cfg.ip), "[CONFIG] kuzzlerc.cluster.ip: invalid value (accepted values: public, private)");
+    (0, assert_1.default)(!cfg.interface || typeof cfg.interface === "string", "[CONFIG] kuzzlerc.cluster.interface: value must be either null, or a string");
+}
+function preprocessHttpOptions(config) {
+    const httpConfig = config.http;
+    if (httpConfig === undefined) {
+        return;
+    }
+    if (typeof httpConfig.accessControlAllowOrigin === "string") {
+        httpConfig.accessControlAllowOrigin = httpConfig.accessControlAllowOrigin
+            .split(",")
+            .map((value) => value.trim());
+    }
+    // Stored to avoid doing includes multiple times later
+    config.internal.allowAllOrigins =
+        httpConfig.accessControlAllowOrigin.includes("*");
+    // If Regular Expression is enabled for accessControlAllowOrigin header we convert every string to a RegExp
+    if (httpConfig.accessControlAllowOriginUseRegExp) {
+        httpConfig.accessControlAllowOrigin =
+            httpConfig.accessControlAllowOrigin.map((pattern) => new RegExp(pattern));
+    }
+}
+function preprocessProtocolsOptions(config) {
+    const protocols = config.server.protocols;
+    config.internal.notifiableProtocols = [];
+    for (const [protocolName, protocolConfig] of Object.entries(protocols)) {
+        if (protocolConfig.enabled && protocolConfig.realtimeNotifications) {
+            config.internal.notifiableProtocols.push(protocolName);
+        }
+    }
+}
+function preprocessRedisOptions(redisConfig) {
+    // @deprecated Remove those lines for Kuzzle v3 then
+    // remove also 'database' from .kuzzlerc.sample.jsonc and default.config
+    if (redisConfig.database) {
+        redisConfig.options = { db: redisConfig.database, ...redisConfig.options };
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/lib/config/sdkCompatibility.json

@@ -0,0 +1,9 @@
+{
+    "js": { "min": 7 },
+    "csharp": { "min": 2 },
+    "cpp": { "min": 2 },
+    "java": { "min": 3 },
+    "android": { "min": 5 },
+    "go": { "min": 3 },
+    "php": { "min": 4 }
+}

package/dist/lib/core/auth/formatProcessing.d.ts

@@ -0,0 +1,30 @@
+import { Profile } from "../../model/security/profile";
+import { Role } from "../../model/security/role";
+import { User } from "../../model/security/user";
+import type { Serialized } from "../../types/core/auth/formatProcessing.type";
+declare const _default: {
+    /**
+     * Serializes profile and transforms it into a POJO
+     *
+     * @param {Profile} profile
+     * @returns {object}
+     */
+    serializeProfile(profile: Profile): Serialized<Profile>;
+    /**
+     * Serializes role and transforms it into a POJO
+     *
+     * @param {Role} role
+     * @returns {Object}
+     */
+    serializeRole(role: Role & {
+        restrictedTo?: unknown;
+    }): Serialized<Role>;
+    /**
+     * Serializes user and transforms it into a POJO
+     *
+     * @param {User} user
+     * @returns {Object}
+     */
+    serializeUser(user: User): Serialized<User>;
+};
+export default _default;

package/dist/lib/core/auth/formatProcessing.js

@@ -0,0 +1,55 @@
+"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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    /**
+     * Serializes profile and transforms it into a POJO
+     *
+     * @param {Profile} profile
+     * @returns {object}
+     */
+    serializeProfile(profile) {
+        const { _id, ..._source } = profile;
+        return { _id, _source: _source };
+    },
+    /**
+     * Serializes role and transforms it into a POJO
+     *
+     * @param {Role} role
+     * @returns {Object}
+     */
+    serializeRole(role) {
+        const { _id, ..._source } = role;
+        return { _id, _source: _source };
+    },
+    /**
+     * Serializes user and transforms it into a POJO
+     *
+     * @param {User} user
+     * @returns {Object}
+     */
+    serializeUser(user) {
+        const { _id, ..._source } = user;
+        return { _id, _source: _source };
+    },
+};
+//# sourceMappingURL=formatProcessing.js.map

package/dist/lib/core/auth/passportResponse.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { OutgoingHttpHeaders } from "http";
+/**
+ * @class PassportResponse
+ */
+export default class PassportResponse {
+    headers: OutgoingHttpHeaders;
+    statusCode: number;
+    private onEndListener;
+    constructor();
+    setHeader(field: string, value: number | string | string[]): void;
+    end(statusCode?: number): void;
+    getHeader(key: string): OutgoingHttpHeaders[string];
+    addEndListener(listener: () => void): void;
+}

package/{lib → dist/lib}/core/auth/passportResponse.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,45 +19,38 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
-"use strict";
-
+Object.defineProperty(exports, "__esModule", { value: true });
 /*
 HTTP Response Mockup to emulate response objects for Passport Authentication
 @TODO: Implement a mockup for each HTTP ServerResponse method
 (see https://nodejs.org/api/http.html#http_class_http_serverresponse)
 */
-
 /**
  * @class PassportResponse
  */
 class PassportResponse {
-  constructor() {
-    this.headers = {};
-    this.statusCode = 200;
-    this.onEndListener = null;
-  }
-
-  setHeader(field, value) {
-    this.headers[field] = value;
-  }
-
-  end(statusCode) {
-    if (statusCode) {
-      this.statusCode = statusCode;
+    constructor() {
+        this.headers = {};
+        this.statusCode = 200;
+        this.onEndListener = null;
+    }
+    setHeader(field, value) {
+        this.headers[field] = value;
+    }
+    end(statusCode) {
+        if (typeof statusCode === "number") {
+            this.statusCode = statusCode;
+        }
+        if (typeof this.onEndListener === "function") {
+            this.onEndListener();
+        }
+    }
+    getHeader(key) {
+        return this.headers[key];
     }
-    if (typeof this.onEndListener === "function") {
-      this.onEndListener();
+    addEndListener(listener) {
+        this.onEndListener = listener;
     }
-  }
-
-  getHeader(key) {
-    return this.headers[key];
-  }
-
-  addEndListener(listener) {
-    this.onEndListener = listener;
-  }
 }
-
-module.exports = PassportResponse;
+exports.default = PassportResponse;
+//# sourceMappingURL=passportResponse.js.map

package/dist/lib/core/auth/passportWrapper.d.ts

@@ -0,0 +1,28 @@
+import { AuthenticateOptions, Strategy } from "passport";
+/**
+ * @class PassportWrapper
+ */
+export default class PassportWrapper {
+    options: Record<string, AuthenticateOptions>;
+    constructor();
+    /**
+     * @param {{query: Object}}request
+     * @param strategyName
+     * @returns {Promise.<*>}
+     */
+    authenticate(request: any, strategyName: string): Promise<unknown>;
+    /**
+     * Exposes passport.use function
+     *
+     * @param {string} name - strategy name
+     * @param {object} strategy - instantiated strategy object
+     * @param {object} opts - options to provide to authenticate with the strategy
+     */
+    use(name: string, strategy: Strategy, opts?: AuthenticateOptions): void;
+    /**
+     * Exposes passport.unuse, unregistering a strategy from kuzzle
+     *
+     * @param  {string} name - name of the strategy to unregister
+     */
+    unuse(name: string): void;
+}

package/dist/lib/core/auth/passportWrapper.js

@@ -0,0 +1,126 @@
+"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 });
+const bluebird_1 = __importDefault(require("bluebird"));
+const passport_1 = __importDefault(require("passport"));
+const errors_1 = require("../../kerror/errors");
+const kerror = __importStar(require("../../kerror"));
+const passportResponse_1 = __importDefault(require("./passportResponse"));
+/**
+ * @class PassportWrapper
+ */
+class PassportWrapper {
+    constructor() {
+        this.options = {};
+    }
+    /**
+     * @param {{query: Object}}request
+     * @param strategyName
+     * @returns {Promise.<*>}
+     */
+    authenticate(request, strategyName) {
+        const response = new passportResponse_1.default();
+        return new bluebird_1.default((resolve, reject) => {
+            // This listener is invoked when a redirection is required by the strategy (e.g. OAUTH)
+            // In that case, the strategy's verify function is not called, and
+            // neither is the authenticate's callback.
+            // Thus, despite the apparences, the promise can only be resolved once.
+            // (Proof: HTTP redirection unit test)
+            response.addEndListener(() => resolve(response));
+            const authCB = (err, user, info) => {
+                if (err !== null) {
+                    if (err instanceof errors_1.KuzzleError) {
+                        reject(err);
+                    }
+                    else {
+                        reject(kerror.getFrom(err, "plugin", "runtime", "unexpected_error", err.message));
+                    }
+                }
+                else if (!user) {
+                    reject(kerror.get("plugin", "strategy", "missing_user", info.message));
+                }
+                else {
+                    resolve(user);
+                }
+            };
+            try {
+                passport_1.default.authenticate(strategyName, this.options[strategyName] || {}, authCB)(request, response);
+            }
+            catch (e) {
+                if (e instanceof errors_1.KuzzleError) {
+                    reject(e);
+                }
+                else {
+                    reject(kerror.getFrom(e, "plugin", "runtime", "unexpected_error", e.message));
+                }
+            }
+        });
+    }
+    /**
+     * Exposes passport.use function
+     *
+     * @param {string} name - strategy name
+     * @param {object} strategy - instantiated strategy object
+     * @param {object} opts - options to provide to authenticate with the strategy
+     */
+    use(name, strategy, opts = {}) {
+        passport_1.default.use(name, strategy);
+        this.options[name] = opts;
+    }
+    /**
+     * Exposes passport.unuse, unregistering a strategy from kuzzle
+     *
+     * @param  {string} name - name of the strategy to unregister
+     */
+    unuse(name) {
+        passport_1.default.unuse(name);
+        delete this.options[name];
+    }
+}
+exports.default = PassportWrapper;
+//# sourceMappingURL=passportWrapper.js.map

package/{lib → dist/lib}/core/backend/backendConfig.js

@@ -50,12 +50,12 @@ exports.BackendConfig = void 0;
 const lodash_1 = __importDefault(require("lodash"));
 const kerror = __importStar(require("../../kerror"));
 const index_1 = require("./index");
-const index_js_1 = require("../../config/index.js");
+const index_2 = require("../../config/index");
 const runtimeError = kerror.wrap("plugin", "runtime");
 class BackendConfig extends index_1.ApplicationManager {
     constructor(application) {
         super(application);
-        this.content = (0, index_js_1.loadConfig)();
+        this.content = (0, index_2.loadConfig)();
     }
     /**
      * Sets a configuration value

package/{lib → dist/lib}/core/backend/backendErrors.js

@@ -69,21 +69,18 @@ class BackendErrors extends index_1.ApplicationManager {
      * ```
      */
     register(domain, subDomain, name, definition) {
-        if (!this.domains[domain]) {
-            this.domains[domain] = {
+        const domainEntry = this.domains[domain] ||
+            (this.domains[domain] = {
                 code: Object.keys(this.domains).length,
                 subDomains: {},
-            };
-        }
-        if (!this.domains[domain].subDomains[subDomain]) {
-            this.domains[domain].subDomains[subDomain] = {
-                code: Object.keys(this.domains[domain].subDomains).length,
+            });
+        const subDomainEntry = domainEntry.subDomains[subDomain] ||
+            (domainEntry.subDomains[subDomain] = {
+                code: Object.keys(domainEntry.subDomains).length,
                 errors: {},
-            };
-        }
-        this.domains[domain].subDomains[subDomain].errors[name] = {
-            code: Object.keys(this.domains[domain].subDomains[subDomain].errors)
-                .length,
+            });
+        subDomainEntry.errors[name] = {
+            code: Object.keys(subDomainEntry.errors).length,
             ...definition,
         };
     }

package/dist/lib/core/cache/cacheEngine.d.ts

@@ -0,0 +1,15 @@
+export = CacheEngine;
+declare class CacheEngine {
+    public: Redis;
+    internal: Redis;
+    logger: import("../../kuzzle/Logger").Logger;
+    /**
+     * Initializes the redis clients
+     *
+     * @returns {Promise}
+     */
+    init(): Promise<any>;
+    registerInternalEvents(): void;
+    registerPublicEvents(): void;
+}
+import Redis = require("../../service/cache/redis");