Implement plugin config prefix

src/server/config/__tests__/config.js

@@ -198,6 +198,14 @@ describe('lib/config/config', function () {
         expect(config.get('myTest.test')).to.be(true);
       });
 
+      it('should allow you to extend the schema with a prefix', function () {
+        var newSchema = Joi.object({ test: Joi.boolean().default(true) }).default();
+        config.extendSchema('prefix.myTest', newSchema);
+        expect(config.get('prefix')).to.eql({ myTest: { test: true }});
+        expect(config.get('prefix.myTest')).to.eql({ test: true });
+        expect(config.get('prefix.myTest.test')).to.be(true);
+      });
+
       it('should NOT allow you to extend the schema if somethign else is there', function () {
         var newSchema = Joi.object({ test: Joi.boolean().default(true) }).default();
         var run = function () {

src/server/config/config.js

@@ -1,33 +1,56 @@
 import Promise from 'bluebird';
 import Joi from 'joi';
 import _ from 'lodash';
+import toPath from 'lodash/internal/toPath';
 import override from './override';
 import createDefaultSchema from './schema';
 import pkg from '../../utils/package_json';
 import clone from './deep_clone_with_buffers';
 import { zipObject } from 'lodash';
 
 const schema = Symbol('Joi Schema');
-const schemaKeys = Symbol('Schema Extensions');
+const schemaExts = Symbol('Schema Extensions');
 const vals = Symbol('config values');
 const pendingSets = Symbol('Pending Settings');
 
+function unset(object, rawPath) {
+  const path = toPath(rawPath);
+
+  switch (path.length) {
+    case 0:
+      return;
+
+    case 1:
+      delete object[rawPath];
+      break;
+
+    default:
+      const leaf = path.pop();
+      const parentPath = path.slice();
+      const parent = _.get(object, parentPath);
+      delete parent[leaf];
+      if (!_.size(parent)) {
+        unset(object, parentPath);
+      }
+      break;
+  }
+}
+
 module.exports = class Config {
   static withDefaultSchema(settings = {}) {
     return new Config(createDefaultSchema(), settings);
   }
 
   constructor(initialSchema, initialSettings) {
-    this[schemaKeys] = new Map();
-
+    this[schemaExts] = Object.create(null);
     this[vals] = Object.create(null);
-    this[pendingSets] = new Map(_.pairs(clone(initialSettings || {})));
+    this[pendingSets] = _.merge(Object.create(null), initialSettings || {});
 
     if (initialSchema) this.extendSchema(initialSchema);
   }
 
   getPendingSets() {
-    return this[pendingSets];
+    return new Map(_.pairs(this[pendingSets]));
   }
 
   extendSchema(key, extension) {
@@ -41,26 +64,27 @@ module.exports = class Config {
       throw new Error(`Config schema already has key: ${key}`);
     }
 
-    this[schemaKeys].set(key, extension);
+    _.set(this[schemaExts], key, extension);
     this[schema] = null;
 
-    let initialVals = this[pendingSets].get(key);
+    let initialVals = _.get(this[pendingSets], key);
     if (initialVals) {
       this.set(key, initialVals);
-      this[pendingSets].delete(key);
+      const path = toPath(key);
+      unset(this[pendingSets], key);
     } else {
       this._commit(this[vals]);
     }
   }
 
   removeSchema(key) {
-    if (!this[schemaKeys].has(key)) {
+    if (!_.has(this[schemaExts], key)) {
       throw new TypeError(`Unknown schema key: ${key}`);
     }
 
     this[schema] = null;
-    this[schemaKeys].delete(key);
-    this[pendingSets].delete(key);
+    unset(this[schemaExts], key);
+    unset(this[pendingSets], key);
     delete this[vals][key];
   }
 
@@ -138,7 +162,7 @@ module.exports = class Config {
       // Catch the partial paths
       if (path.join('.') === key) return true;
       // Only go deep on inner objects with children
-      if (schema._inner.children.length) {
+      if (_.size(schema._inner.children)) {
         for (let i = 0; i < schema._inner.children.length; i++) {
           let child = schema._inner.children[i];
           // If the child is an object recurse through it's children and return
@@ -163,8 +187,23 @@ module.exports = class Config {
 
   getSchema() {
     if (!this[schema]) {
-      let objKeys = zipObject([...this[schemaKeys]]);
-      this[schema] = Joi.object().keys(objKeys).default();
+      this[schema] = (function convertToSchema(children) {
+        let objKeys = zipObject([...children]);
+        let schema = Joi.object().keys(objKeys).default();
+
+        for (const key of Object.keys(children)) {
+          const child = children[key];
+          const childSchema = _.isPlainObject(child) ? convertToSchema(child) : child;
+
+          if (!childSchema || !childSchema.isJoi) {
+            throw new TypeError('Unable to convert configuration definition value to Joi schema: ' + childSchema);
+          }
+
+          schema = schema.keys({ [key]: childSchema });
+        }
+
+        return schema;
+      }(this[schemaExts]));
     }
 
     return this[schema];

src/server/plugins/plugin.js

@@ -1,4 +1,5 @@
 import _ from 'lodash';
+import toPath from 'lodash/internal/toPath';
 import Joi from 'joi';
 import { attempt, fromNode } from 'bluebird';
 import { basename, resolve } from 'path';
@@ -35,6 +36,8 @@ const defaultConfigSchema = Joi.object({
  * @param {String} [opts.version=pkg.version] - the version of this plugin
  * @param {Function} [opts.init] - A function that will be called to initialize
  *                               this plugin at the appropriate time.
+ * @param {Function} [opts.configPrefix=this.id] - The prefix to use for configuration
+ *                               values in the main configuration service
  * @param {Function} [opts.config] - A function that produces a configuration
  *                                 schema using Joi, which is passed as its
  *                                 first argument.
@@ -55,6 +58,7 @@ module.exports = class Plugin {
     this.requiredIds = opts.require || [];
     this.version = opts.version || pkg.version;
     this.externalInit = opts.init || _.noop;
+    this.configPrefix = opts.configPrefix || this.id;
     this.getConfigSchema = opts.config || _.noop;
     this.init = _.once(this.init);
 
@@ -83,18 +87,18 @@ module.exports = class Plugin {
   async readConfig() {
     let schema = await this.getConfigSchema(Joi);
     let { config } = this.kbnServer;
-    config.extendSchema(this.id, schema || defaultConfigSchema);
+    config.extendSchema(this.configPrefix, schema || defaultConfigSchema);
 
-    if (config.get([this.id, 'enabled'])) {
+    if (config.get([...toPath(this.configPrefix), 'enabled'])) {
       return true;
     } else {
-      config.removeSchema(this.id);
+      config.removeSchema(this.configPrefix);
       return false;
     }
   }
 
   async init() {
-    let { id, version, kbnServer } = this;
+    let { id, version, kbnServer, configPrefix } = this;
     let { config } = kbnServer;
 
     // setup the hapi register function and get on with it
@@ -127,7 +131,7 @@ module.exports = class Plugin {
     await fromNode(cb => {
       kbnServer.server.register({
         register: register,
-        options: config.has(id) ? config.get(id) : null
+        options: config.has(configPrefix) ? config.get(configPrefix) : null
       }, cb);
     });