don't prevalidate config

platform/config/ConfigService.ts

@@ -1,10 +1,11 @@
 import { BehaviorSubject, Observable } from 'rxjs';
 import { isEqual } from 'lodash';
 
-import { Config } from './Config';
 import { getRawConfig, applyArgv } from './readConfig';
 import { Env } from '../env';
 import { logger } from '../logger';
+import { Setting, Any, TypeOf } from '../lib/schema';
+import { ConfigWithSchema } from '../types';
 
 const log = logger.get('settings');
 
@@ -16,26 +17,24 @@ export class ConfigService {
   private readonly rawConfigFromFile$: BehaviorSubject<RawConfig | void> =
     new BehaviorSubject(undefined)
 
-  private readonly config$: Observable<Config>;
+  private readonly rawConfig$: Observable<RawConfig>;
 
   constructor(
     private readonly argv: {[key: string]: any},
     private readonly env: Env
   ) {
-    this.config$ = this.rawConfigFromFile$
+    this.rawConfig$ = this.rawConfigFromFile$
       .filter(rawConfig => rawConfig !== undefined)
       // we need to specify the type here, as we _know_ `RawConfig` no longer
       // can be `undefined`.
       .map<RawConfig, RawConfig>(rawConfig => applyArgv(argv, rawConfig))
       // we only care about reloading the config if there are changes
-      .distinctUntilChanged((prev, next) => isEqual(prev, next))
-      .map(config => Config.create(config, env));
+      .distinctUntilChanged((prev, next) => isEqual(prev, next));
   }
 
   /**
    * Reads the initial Kibana config
    */
-  // TODO inject schema?
   start() {
     this.loadConfig();
   }
@@ -58,7 +57,35 @@ export class ConfigService {
     this.rawConfigFromFile$.complete();
   }
 
-  getConfig() {
-    return this.config$;
+  atPath<Schema extends Any, Config>(
+    path: string,
+    ConfigClass: ConfigWithSchema<Schema, Config>
+  ) {
+    return this.getDistinctRawConfig(path)
+      .map(value => {
+        const config = ConfigClass.schema.validate(value);
+        return new ConfigClass(config, this.env);
+      });
+  }
+
+  optionalAtPath<Schema extends Any, Config>(
+    path: string,
+    ConfigClass: ConfigWithSchema<Schema, Config>
+  ) {
+    return this.getDistinctRawConfig(path)
+      .map(value => {
+        if (value === undefined) {
+          return undefined;
+        }
+
+        const config = ConfigClass.schema.validate(value);
+        return new ConfigClass(config, this.env);
+      });
+  }
+
+  private getDistinctRawConfig(path: string) {
+    return this.rawConfig$
+      .map(config => config[path])
+      .distinctUntilChanged((prev, next) => isEqual(prev, next))
   }
-}
+}

platform/config/index.ts

@@ -1,2 +1 @@
 export { ConfigService } from './ConfigService';
-export { Config } from './Config';

platform/logger/LoggerConfig.ts

@@ -19,6 +19,8 @@ export const loggerSchema = object({
 export type LoggingSchema = TypeOf<typeof loggerSchema>;
 
 export class LoggerConfig {
+  static schema = loggerSchema;
+
   readonly dest: string;
   private readonly silent: boolean;
   private readonly quiet: boolean;

platform/root/index.ts

@@ -4,6 +4,7 @@ import { Server } from '../server';
 import { Env } from '../env';
 import { ConfigService } from '../config';
 import { loggerService, logger, LoggerConfig } from '../logger';
+import { HttpModule } from '../server/http'
 
 const log = logger.get('root');
 
@@ -23,16 +24,16 @@ export class Root {
   start() {
     this.configService.start();
 
-    const config$ = this.configService.getConfig();
-
-    const loggingConfig$ = config$
-      .map(config => new LoggerConfig(config.atPath('logging')));
+    const loggingConfig$ = this.configService.atPath(
+      'logging',
+      LoggerConfig
+    );
 
     loggerService.upgrade(loggingConfig$);
 
     log.info('starting the server');
 
-    this.server = new Server(config$);
+    this.server = new Server(this.configService);
     this.server.start();
   }
 

platform/server/elasticsearch/ElasticsearchConfigs.ts

@@ -1,11 +1,13 @@
 import { ElasticsearchConfig } from './ElasticsearchConfig';
-import { ElasticsearchConfigsSchema } from './schema';
+import { elasticsearchSchema, ElasticsearchConfigsSchema } from './schema';
 
 import { Env } from '../../env';
 
 export type ElasticsearchClusterType = 'data' | 'admin';
 
 export class ElasticsearchConfigs {
+  static schema = elasticsearchSchema;
+
   private readonly elasticsearchConfigs: {
     data: ElasticsearchConfig,
     admin: ElasticsearchConfig

platform/server/elasticsearch/index.ts

@@ -5,22 +5,19 @@ import { ElasticsearchFacade } from './ElasticsearchFacade';
 import { createElasticsearchRoutes } from './api';
 import { RouterFactory } from '../http';
 import { IsRouteable } from '../../types';
-import { Config } from '../../config';
 import { Schema } from '../../types';
 import { ElasticsearchConfigs } from './ElasticsearchConfigs';
 
-export { elasticsearchSchema } from './schema';
+import { elasticsearchSchema } from './schema';
 export { ElasticsearchService, ElasticsearchFacade, ElasticsearchConfigs };
 
 export class ElasticsearchModule implements IsRouteable {
+  static config = ElasticsearchConfigs;
+
   readonly service: ElasticsearchService;
   readonly facade: ElasticsearchFacade;
-  readonly config$: Observable<ElasticsearchConfigs>;
 
-  constructor(config$: Observable<Config>) {
-    this.config$ = config$.map(config =>
-      new ElasticsearchConfigs(config.atPath('elasticsearch'), config.env)
-    );
+  constructor(readonly config$: Observable<ElasticsearchConfigs>) {
     this.service = new ElasticsearchService(this.config$);
     this.facade = new ElasticsearchFacade(this.service);
   }

platform/server/http/HttpConfig.ts

@@ -39,6 +39,8 @@ export const httpSchema = object({
 export type HttpSchema = TypeOf<typeof httpSchema>;
 
 export class HttpConfig {
+  static schema = httpSchema;
+
   host: string;
   port: number;
   maxPayload: ByteSizeValue;

platform/server/http/index.ts

@@ -1,22 +1,20 @@
 import { Observable } from 'rxjs';
 
-import { Config } from '../../config';
 import { HttpService } from './HttpService';
 import { HttpConfig } from './HttpConfig';
 import { Routers } from './Routing';
+import { httpSchema } from './HttpConfig';
 
 export { httpSchema } from './HttpConfig';
 export { KibanaRequest, KibanaResponse, RouterFactory, Router } from './Routing';
 export { HttpService, Routers };
 
 export class HttpModule {
+  static config = HttpConfig;
+
   readonly service: HttpService;
-  readonly config$: Observable<HttpConfig>;
 
-  constructor(config$: Observable<Config>, routers: Routers) {
-    this.config$ = config$.map(config =>
-      new HttpConfig(config.atPath('server'), config.env)
-    );
+  constructor(readonly config$: Observable<HttpConfig>, routers: Routers) {
     this.service = new HttpService(this.config$, routers.routers$);
   }
 }

platform/server/index.ts

@@ -1,17 +1,19 @@
 import { Observable, ReplaySubject } from 'rxjs';
+import { isEqual } from 'lodash';
 
+import { ConfigService } from '../config';
 import { HttpModule, Routers } from './http';
 import { PidModule } from './pid';
 import { SavedObjectsModule } from './savedObjects';
 import { ElasticsearchModule } from './elasticsearch';
 import { KibanaModule } from './kibana';
 import { logger } from '../logger';
-import { Config } from '../config';
 import * as schema from '../lib/schema';
 import { KibanaRequestHelpers } from '../types';
 
 const log = logger.get('server');
 
+
 export class Server {
   private readonly elasticsearch: ElasticsearchModule;
   private readonly http: HttpModule;
@@ -21,11 +23,32 @@ export class Server {
   private readonly routers: Routers;
 
   constructor(
-    private readonly config$: Observable<Config>
+    private readonly configService: ConfigService
   ) {
-    this.pid = new PidModule(config$);
-    this.elasticsearch = new ElasticsearchModule(config$);
-    this.kibana = new KibanaModule(config$);
+    const pidConfig$ = configService.optionalAtPath(
+      'pid', PidModule.config
+    );
+
+    const elasticsearchConfigs$ = configService.atPath(
+      'elasticsearch', ElasticsearchModule.config
+    );
+
+    const kibanaConfig$ = configService.atPath(
+      'kibana', KibanaModule.config
+    );
+
+    const httpConfig$ = configService.atPath(
+      'server', HttpModule.config
+    );
+
+    // const configObservables = configService.getConfigFor({
+    //   ...coreConfigs,
+    //   pid: PidModule.config
+    // })
+
+    this.pid = new PidModule(pidConfig$);
+    this.elasticsearch = new ElasticsearchModule(elasticsearchConfigs$);
+    this.kibana = new KibanaModule(kibanaConfig$);
     this.savedObjects = new SavedObjectsModule(
       this.kibana.config$,
       this.elasticsearch.service
@@ -53,8 +76,51 @@ export class Server {
       savedObjects: this.savedObjects.facade
     };
 
+    // const kibanaForPlugins: KibanaHelpers = {
+    //   services: {
+    //     elasticsearch: this.elasticsearch.service
+    //   }
+    // }
+
+    // const plugins = [
+    //   watcher,
+    //   monitoring
+    // ]
+
+    // topologicalSort(plugins).map(plugin => plugin(kibanaForPlugins))
+    // type Monitoring = {
+    //   key: string
+    // }
+
+    // type MonitoringHelper = {
+    //   monitoring: Monitoring
+    // }
+
+    // type TestHelper = {
+    //   test: {
+    //     foo: number
+    //   }
+    // }
+
+    // type MyHelper = {
+    //   test?: TestHelper,
+    //   monitoring: Monitoring
+    // }
+
+    // class KibanaPlugin<T> {
+    //   constructor(obj: T) {
+    //   }
+    // }
+
+    // class WatcherPlugin extends KibanaPlugin<MyHelper> {
+    // }
+
+    // new WatcherPlugin({
+    //   monitoring
+    // })
+
     this.routers = new Routers(kibana);
-    this.http = new HttpModule(config$, this.routers);
+    this.http = new HttpModule(httpConfig$, this.routers);
   }
 
   start() {

platform/server/kibana/KibanaConfig.ts

@@ -1,6 +1,8 @@
-import { KibanaConfigSchema } from './schema';
+import { kibanaSchema, KibanaConfigSchema } from './schema';
 
 export class KibanaConfig {
+  static schema = kibanaSchema;
+
   readonly index: string;
 
   constructor(config: KibanaConfigSchema) {