kuzzle 2.16.11 → 2.17.2

package/lib/api/openapi/openApiGenerator.js

@@ -0,0 +1,133 @@
+"use strict";
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2020 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.generateOpenApi = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const inflector_1 = require("../../util/inflector");
+const routeUrlMatch = /:([^/]*)/g;
+/**
+ * Generate basic openApi Controller
+ */
+function generateController(route, definition) {
+    if (route.controller === undefined) {
+        return;
+    }
+    if (!lodash_1.default.some(definition.tags, { name: route.controller })) {
+        const capitalizedController = inflector_1.Inflector.pascalCase(route.controller);
+        definition.tags.push({
+            description: `${capitalizedController} Controller`,
+            name: route.controller
+        });
+    }
+    if (route.openapi.tags === undefined) {
+        route.openapi.tags = [];
+    }
+    if (!route.openapi.tags.includes(route.controller)) {
+        route.openapi.tags.push(route.controller);
+    }
+}
+/**
+ * Generate basic openApi Summary
+ */
+function generateSummary(route) {
+    if (route.openapi.description === undefined) {
+        route.openapi.description = `Controller: ${route.controller}.`;
+    }
+    if (route.openapi.summary === undefined) {
+        route.openapi.summary = `Action: ${route.action}.`;
+    }
+}
+/**
+ * Generate basic openApi Parameters
+ */
+function generateParameters(route) {
+    if (route.openapi.parameters === undefined) {
+        route.openapi.parameters = [];
+        let m = routeUrlMatch.exec(route.path);
+        while (m !== null) {
+            routeUrlMatch.lastIndex++;
+            route.openapi.parameters.push({
+                in: 'path',
+                name: m[1],
+                required: true,
+                schema: { type: 'string' }
+            });
+            m = routeUrlMatch.exec(route.path);
+        }
+    }
+    if (route.openapi.parameters.length === 0) {
+        route.openapi.parameters = undefined;
+    }
+}
+/**
+ * Generate basic openApi Response
+ */
+function generateResponse(route) {
+    if (route.openapi.responses === undefined) {
+        route.openapi.responses = {
+            '200': {
+                description: 'OK'
+            }
+        };
+    }
+}
+/**
+ * Generates JSON OpenApi object
+ *
+ * @returns {object} openApi object
+ */
+function generateOpenApi(routes, definition) {
+    for (const route of routes) {
+        // Make sure route verbs are lowercase
+        if (route.verb !== undefined) {
+            route.verb = route.verb.toLowerCase();
+        }
+        // Set :param notation to {param}
+        route.formattedPath = route.path.replace(routeUrlMatch, '{$1}');
+        if (definition.paths[route.formattedPath] === undefined) {
+            definition.paths[route.formattedPath] = {};
+        }
+        if (definition.paths[route.formattedPath][route.verb] !== undefined) {
+            continue;
+        }
+        // If custom specification, return as it is
+        if (route.openapi) {
+            generateController(route, definition);
+            definition.paths[route.formattedPath][route.verb] = route.openapi;
+            continue;
+        }
+        if (route.openapi === undefined) {
+            route.openapi = {};
+        }
+        generateController(route, definition);
+        generateSummary(route);
+        generateParameters(route);
+        generateResponse(route);
+        definition.paths[route.formattedPath][route.verb] = route.openapi;
+    }
+    return definition;
+}
+exports.generateOpenApi = generateOpenApi;
+//# sourceMappingURL=openApiGenerator.js.map

package/lib/api/request/kuzzleRequest.js

@@ -38,9 +38,6 @@ 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.Request = exports.KuzzleRequest = void 0;
 const uuid = __importStar(require("uuid"));
@@ -49,11 +46,12 @@ const requestInput_1 = require("./requestInput");
 const requestResponse_1 = require("./requestResponse");
 const requestContext_1 = require("./requestContext");
 const errors_1 = require("../../kerror/errors");
-const kerror_1 = __importDefault(require("../../kerror"));
+const kerror = __importStar(require("../../kerror"));
+const types_1 = require("../../types");
 const assert = __importStar(require("../../util/assertType"));
 const safeObject_1 = require("../../util/safeObject");
 const lodash_1 = require("lodash");
-const assertionError = kerror_1.default.wrap('api', 'assert');
+const assertionError = kerror.wrap('api', 'assert');
 // private properties
 // \u200b is a zero width space, used to masquerade console.log output
 const _internalId = 'internalId\u200b';
@@ -217,6 +215,9 @@ class KuzzleRequest {
         if (result instanceof Error) {
             throw new errors_1.InternalError('cannot set an error as a request\'s response');
         }
+        if (this.context.connection.protocol !== 'http' && result instanceof types_1.HttpStream) {
+            throw kerror.get('api', 'assert', 'forbidden_stream');
+        }
         this.status = options.status || 200;
         if (options.headers) {
             this.response.setHeaders(options.headers);
@@ -320,7 +321,7 @@ class KuzzleRequest {
     getLangParam() {
         const lang = this.getString('lang', 'elasticsearch');
         if (lang !== 'elasticsearch' && lang !== 'koncorde') {
-            throw kerror_1.default.get('api', 'assert', 'invalid_argument', 'lang', '"elasticsearch" or "koncorde"');
+            throw kerror.get('api', 'assert', 'invalid_argument', 'lang', '"elasticsearch" or "koncorde"');
         }
         return lang;
     }
@@ -585,6 +586,7 @@ class KuzzleRequest {
      */
     getId(options = { generator: uuid.v4, ifMissing: 'error' }) {
         const id = this.input.args._id;
+        options.generator = options.generator || uuid.v4; // Default to uuid v4
         if (!id) {
             if (options.ifMissing === 'generate') {
                 return options.generator();

package/lib/cluster/node.js

@@ -110,10 +110,10 @@ function getIP ({ family = 'IPv4', interface: netInterface, ip } = {}) {
   debug('Found interfaces %o', interfaces);
 
   interfaces = interfaces.filter(n => {
-    return !n.internal
-      && !isInternalIP(n.address)
+    return ! n.internal
+      && ! isInternalIP(n.address)
       && n.family === family
-      && (!ip || mustBePrivate === isPrivateIP(n.address));
+      && (! ip || mustBePrivate === isPrivateIP(n.address));
   });
 
   debug('Filtered interfaces %o', interfaces);
@@ -123,7 +123,7 @@ function getIP ({ family = 'IPv4', interface: netInterface, ip } = {}) {
   }
 
   // take the first IP from the list if no interface has been defined
-  if (!netInterface) {
+  if (! netInterface) {
     return interfaces[0].address;
   }
 
@@ -298,7 +298,7 @@ class ClusterNode {
   async evictNode (nodeId, { broadcast = false, reason = '' }) {
     const subscriber = this.remoteNodes.get(nodeId);
 
-    if (!subscriber) {
+    if (! subscriber) {
       return;
     }
 
@@ -358,7 +358,7 @@ class ClusterNode {
             return split.every((id, index) => id === topology[index]);
           });
 
-          if (!found) {
+          if (! found) {
             splits.push(topology);
           }
         }
@@ -415,13 +415,13 @@ class ClusterNode {
 
         for (let i = 0; i < isolatedNodes.length; i++) {
           const idCard = idCards.find(card => card.id === isolatedNodes[i]);
-          if (!youngestNode || idCard.birthdate > youngestNode.birthdate) {
+          if (! youngestNode || idCard.birthdate > youngestNode.birthdate) {
             youngestNode = idCard;
           }
         }
 
         if (isIsolated) {
-          for (let i = 0; !candidates && i < eligibleSplits.length; i++) {
+          for (let i = 0; ! candidates && i < eligibleSplits.length; i++) {
             if (eligibleSplits[i].includes(youngestNode.id)) {
               candidates = _.intersection(eligibleSplits[i], isolatedNodes);
             }
@@ -621,7 +621,7 @@ class ClusterNode {
   async getStatus () {
     const status = {
       activeNodes: 0,
-      activity: this.activity.map(({address, date, event, id, reason}) => ({
+      activity: this.activity.map(({ address, date, event, id, reason }) => ({
         address,
         date,
         event: event === nodeActivityEnum.ADDED ? 'joined' : 'evicted',

package/lib/cluster/publisher.js

@@ -337,7 +337,7 @@ class ClusterPublisher {
    * @return {void}
    */
   async bufferSend (topic, data) {
-    this.buffer.push({data, topic});
+    this.buffer.push({ data, topic });
 
     if (this.state === STATE.SENDING) {
       return;

package/lib/cluster/state.js

@@ -19,15 +19,31 @@
  * 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 };
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 });
 const koncorde_1 = require("koncorde");
-const kerror_1 = __importDefault(require("../kerror"));
+const kerror = __importStar(require("../kerror"));
 require("../types/Global");
 const koncordeCompat_1 = require("../util/koncordeCompat");
-const errorFatal = kerror_1.default.wrap('cluster', 'fatal');
+const errorFatal = kerror.wrap('cluster', 'fatal');
 /**
  * Private class aiming at maintaining both the number of a node's subscriptions
  * to a room, and the node's last message ID to detect desyncs.

package/lib/cluster/subscriber.js

@@ -667,7 +667,7 @@ class ClusterSubscriber {
    * @return {boolean} false: the message must be discarded, true otherwise
    */
   async validateMessage (message) {
-    if (!has(message, 'messageId')) {
+    if (! has(message, 'messageId')) {
       global.kuzzle.log.warn(`Invalid message received from node ${this.remoteNodeId}. Evicting it.`);
 
       await this.evictNode({

package/lib/cluster/workers/IDCardRenewer.js

@@ -44,7 +44,7 @@ class IDCardRenewer {
      * which could be enough to make the ID Card expire.
      */
     await this.renewIDCard();
-    if (!this.disposed) {
+    if (! this.disposed) {
       this.refreshTimer = setInterval(
         this.renewIDCard.bind(this),
         this.refreshDelay);
@@ -110,7 +110,7 @@ class IDCardRenewer {
   }
 }
 
-if (!isMainThread) {
+if (! isMainThread) {
   const idCardRenewer = new IDCardRenewer();
 
   parentPort.on('message', async message => {

package/lib/config/default.config.js

@@ -380,6 +380,7 @@ const defaultConfig = {
         statsInterval: 10
     },
     cluster: {
+        enabled: true,
         activityDepth: 50,
         heartbeat: 2000,
         interface: null,

package/lib/config/index.js

@@ -80,7 +80,7 @@ function loadConfig () {
  */
 function unstringify (cfg) {
   Object.keys(cfg)
-    .filter(k => !/version$/i.test(k) && (typeof cfg[k] === 'string' || cfg[k] instanceof Object))
+    .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') {
@@ -138,7 +138,7 @@ function checkLimitsConfig (cfg) {
     'subscriptionDocumentTTL'
   ];
 
-  if (!isPlainObject(cfg.limits)) {
+  if (! isPlainObject(cfg.limits)) {
     throw kerror.get('invalid_type', 'limits', 'object');
   }
 
@@ -148,7 +148,7 @@ function checkLimitsConfig (cfg) {
     }
 
     if ( cfg.limits[opt] < 0
-      || cfg.limits[opt] === 0 && !canBeZero.includes(opt)
+      || cfg.limits[opt] === 0 && ! canBeZero.includes(opt)
     ) {
       const allowed = `>= ${canBeZero.includes(opt) ? '0' : '1'}`;
       throw kerror.get('out_of_range', `limits.${opt}`, allowed);
@@ -221,9 +221,9 @@ function checkClusterOptions (config) {
   if (`${cfg.ip}`.length === 0 || cfg.ip === 'null') {
     cfg.ip = null;
   }
-  assert(!cfg.ip || ['private', 'public'].includes(cfg.ip), '[CONFIG] kuzzlerc.cluster.ip: invalid value (accepted values: public, private)');
+  assert(! cfg.ip || ['private', 'public'].includes(cfg.ip), '[CONFIG] kuzzlerc.cluster.ip: invalid value (accepted values: public, private)');
 
-  assert(!cfg.interface || typeof cfg.interface === 'string', '[CONFIG] kuzzlerc.cluster.interface: value must be either null, or a string');
+  assert(! cfg.interface || typeof cfg.interface === 'string', '[CONFIG] kuzzlerc.cluster.interface: value must be either null, or a string');
 }
 
 function preprocessHttpOptions (config) {
@@ -251,7 +251,7 @@ function preprocessHttpOptions (config) {
   }
 }
 
-function preprocessProtocolsOptions(config) {
+function preprocessProtocolsOptions (config) {
   const protocols = config.server.protocols;
 
   config.internal.notifiableProtocols = [];

package/lib/core/auth/passportResponse.js

@@ -31,30 +31,30 @@ HTTP Response Mockup to emulate response objects for Passport Authentication
  * @class PassportResponse
  */
 class PassportResponse {
-  constructor() {
+  constructor () {
     this.headers = {};
     this.statusCode = 200;
     this.onEndListener = null;
   }
 
-  setHeader(field, value) {
+  setHeader (field, value) {
     this.headers[field] = value;
   }
 
-  end(statusCode) {
+  end (statusCode) {
     if (statusCode) {
       this.statusCode = statusCode;
     }
-    if(typeof this.onEndListener === 'function') {
+    if (typeof this.onEndListener === 'function') {
       this.onEndListener();
     }
   }
 
-  getHeader(key) {
+  getHeader (key) {
     return this.headers[key];
   }
 
-  addEndListener(listener) {
+  addEndListener (listener) {
     this.onEndListener = listener;
   }
 }

package/lib/core/auth/passportWrapper.js

@@ -32,7 +32,7 @@ const PassportResponse = require('./passportResponse');
  * @class PassportWrapper
  */
 class PassportWrapper {
-  constructor() {
+  constructor () {
     this.options = {};
   }
 
@@ -41,7 +41,7 @@ class PassportWrapper {
    * @param strategyName
    * @returns {Promise.<*>}
    */
-  authenticate(request, strategyName) {
+  authenticate (request, strategyName) {
     const response = new PassportResponse();
 
     return new Bluebird((resolve, reject) => {
@@ -67,7 +67,7 @@ class PassportWrapper {
                 err.message));
           }
         }
-        else if (!user) {
+        else if (! user) {
           reject(
             kerror.get('plugin', 'strategy', 'missing_user', info.message));
         }
@@ -103,7 +103,7 @@ class PassportWrapper {
    * @param {object} strategy - instantiated strategy object
    * @param {object} opts - options to provide to authenticate with the strategy
    */
-  use(name, strategy, opts = {}) {
+  use (name, strategy, opts = {}) {
     passport.use(name, strategy);
     this.options[name] = opts;
   }
@@ -113,7 +113,7 @@ class PassportWrapper {
    *
    * @param  {string} name - name of the strategy to unregister
    */
-  unuse(name) {
+  unuse (name) {
     passport.unuse(name);
     delete this.options[name];
   }

package/lib/core/backend/backend.d.ts

@@ -1,6 +1,6 @@
 import { EmbeddedSDK } from '../shared/sdk/embeddedSdk';
 import { JSONObject } from '../../../index';
-import { BackendCluster, BackendConfig, BackendController, BackendHook, BackendImport, BackendPipe, BackendPlugin, BackendStorage, BackendVault, InternalLogger } from './index';
+import { BackendCluster, BackendConfig, BackendController, BackendHook, BackendImport, BackendPipe, BackendPlugin, BackendStorage, BackendVault, BackendOpenApi, InternalLogger, BackendErrors } from './index';
 export declare class Backend {
     private _kuzzle;
     private _name;
@@ -113,14 +113,22 @@ export declare class Backend {
      * @method userMappings - Import user mappings
      */
     import: BackendImport;
+    /**
+     * OpenApi manager
+     */
+    openApi: BackendOpenApi;
+    /**
+     * Standard errors
+     */
+    errors: BackendErrors;
     /**
      * @deprecated
      *
+     * Use the app.import.xxx() feature instead.
+     *
      * Support for old features available before Kuzzle as a framework
      * to avoid breaking existing deployments.
      *
-     * Do not use this property unless you know exactly what you are doing,
-     * this property can be removed in future releases.
      */
     _support: JSONObject;
     /**

package/lib/core/backend/backend.js

@@ -46,10 +46,10 @@ exports.Backend = void 0;
 const fs_1 = __importDefault(require("fs"));
 const kuzzle_1 = __importDefault(require("../../kuzzle"));
 const embeddedSdk_1 = require("../shared/sdk/embeddedSdk");
-const kerror_1 = __importDefault(require("../../kerror"));
+const kerror = __importStar(require("../../kerror"));
 const index_1 = require("./index");
-const assertionError = kerror_1.default.wrap('plugin', 'assert');
-const runtimeError = kerror_1.default.wrap('plugin', 'runtime');
+const assertionError = kerror.wrap('plugin', 'assert');
+const runtimeError = kerror.wrap('plugin', 'runtime');
 let _app = null;
 Reflect.defineProperty(global, 'app', {
     configurable: true,
@@ -95,11 +95,11 @@ class Backend {
         /**
          * @deprecated
          *
+         * Use the app.import.xxx() feature instead.
+         *
          * Support for old features available before Kuzzle as a framework
          * to avoid breaking existing deployments.
          *
-         * Do not use this property unless you know exactly what you are doing,
-         * this property can be removed in future releases.
          */
         this._support = {};
         /**
@@ -127,6 +127,13 @@ class Backend {
                 this.started = true;
             },
         ];
+        try {
+            const info = JSON.parse(fs_1.default.readFileSync('./package.json', 'utf8'));
+            this.version = info.version;
+        }
+        catch (error) {
+            // Silent if no version can be found
+        }
         global.app = this;
         this.pipe = new index_1.BackendPipe(this);
         this.hook = new index_1.BackendHook(this);
@@ -138,14 +145,9 @@ class Backend {
         this.import = new index_1.BackendImport(this);
         this.log = new index_1.InternalLogger(this);
         this.cluster = new index_1.BackendCluster();
-        this.kerror = kerror_1.default;
-        try {
-            const info = JSON.parse(fs_1.default.readFileSync('./package.json', 'utf8'));
-            this.version = info.version;
-        }
-        catch (error) {
-            // Silent if no version can be found
-        }
+        this.openApi = new index_1.BackendOpenApi(this);
+        this.errors = new index_1.BackendErrors(this);
+        this.kerror = kerror;
         try {
             this.commit = this._readCommit();
         }
@@ -171,6 +173,7 @@ class Backend {
         const application = new this.PluginObject(this._instanceProxy, { application: true, name: this.name });
         application.version = this.version;
         application.commit = this.commit;
+        application.openApi = this.openApi.definition;
         const options = {
             import: this._import,
             installations: this._installationsWaitingList,
@@ -211,20 +214,22 @@ class Backend {
             throw runtimeError.get('already_started', 'install');
         }
         if (typeof id !== 'string') {
-            throw kerror_1.default.get('validation', 'assert', 'invalid_type', 'id', 'string');
+            throw kerror.get('validation', 'assert', 'invalid_type', 'id', 'string');
         }
         if (typeof handler !== 'function') {
-            throw kerror_1.default.get('validation', 'assert', 'invalid_type', 'handler', 'function');
+            throw kerror.get('validation', 'assert', 'invalid_type', 'handler', 'function');
         }
         if (description && typeof description !== 'string') {
-            throw kerror_1.default.get('validation', 'assert', 'invalid_type', 'id', 'string');
+            throw kerror.get('validation', 'assert', 'invalid_type', 'id', 'string');
         }
         this._installationsWaitingList.push({ description, handler, id });
     }
     /**
      * Application Name
      */
-    get name() { return this._name; }
+    get name() {
+        return this._name;
+    }
     /**
      * EmbeddedSDK instance
      */

package/lib/core/backend/backendConfig.d.ts

@@ -2,13 +2,15 @@ import { ApplicationManager, Backend } from './index';
 import { KuzzleConfiguration } from '../../types/config/KuzzleConfiguration';
 export declare class BackendConfig extends ApplicationManager {
     /**
-     * Configuration content
+     * Configuration content.
      */
     content: KuzzleConfiguration;
     constructor(application: Backend);
     /**
      * Sets a configuration value
      *
+     * @deprecated use app.config.content instead
+     *
      * @param path - Path to the configuration key (lodash style)
      * @param value - Value for the configuration key
      */
@@ -16,6 +18,8 @@ export declare class BackendConfig extends ApplicationManager {
     /**
      * Merges a configuration object into the current configuration
      *
+     * @deprecated use app.config.content instead
+     *
      * @param config - Configuration object to merge
      */
     merge(config: KuzzleConfiguration): void;

package/lib/core/backend/backendConfig.js

@@ -19,16 +19,35 @@
  * 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;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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.BackendConfig = void 0;
 const lodash_1 = __importDefault(require("lodash"));
-const kerror_1 = __importDefault(require("../../kerror"));
+const kerror = __importStar(require("../../kerror"));
 const index_1 = require("./index");
 const index_js_1 = require("../../config/index.js");
-const runtimeError = kerror_1.default.wrap('plugin', 'runtime');
+const runtimeError = kerror.wrap('plugin', 'runtime');
 class BackendConfig extends index_1.ApplicationManager {
     constructor(application) {
         super(application);
@@ -37,6 +56,8 @@ class BackendConfig extends index_1.ApplicationManager {
     /**
      * Sets a configuration value
      *
+     * @deprecated use app.config.content instead
+     *
      * @param path - Path to the configuration key (lodash style)
      * @param value - Value for the configuration key
      */
@@ -49,6 +70,8 @@ class BackendConfig extends index_1.ApplicationManager {
     /**
      * Merges a configuration object into the current configuration
      *
+     * @deprecated use app.config.content instead
+     *
      * @param config - Configuration object to merge
      */
     merge(config) {