[New Platform] Validate config upfront

src/core/server/config/config_service.mock.ts

@@ -31,6 +31,7 @@ const createConfigServiceMock = () => {
     getUsedPaths: jest.fn(),
     getUnusedPaths: jest.fn(),
     isEnabledAtPath: jest.fn(),
+    preSetup: jest.fn(),
   };
   mocked.atPath.mockReturnValue(new BehaviorSubject({}));
   mocked.getConfig$.mockReturnValue(new BehaviorSubject(new ObjectToConfigAdapter({})));

src/core/server/config/config_service.test.ts

@@ -34,9 +34,18 @@ const emptyArgv = getEnvOptions();
 const defaultEnv = new Env('/kibana', emptyArgv);
 const logger = loggingServiceMock.create();
 
+class ExampleClassWithStringSchema {
+  public static schema = schema.string();
+
+  constructor(readonly value: string) {}
+}
+
+const stringSchemaFor = (key: string) => new Map([[key, schema.string()]]);
+
 test('returns config at path as observable', async () => {
   const config$ = new BehaviorSubject(new ObjectToConfigAdapter({ key: 'foo' }));
   const configService = new ConfigService(config$, defaultEnv, logger);
+  configService.preSetup(stringSchemaFor('key'));
 
   const configs = configService.atPath('key', ExampleClassWithStringSchema);
   const exampleConfig = await configs.pipe(first()).toPromise();
@@ -50,6 +59,8 @@ test('throws if config at path does not match schema', async () => {
   const config$ = new BehaviorSubject(new ObjectToConfigAdapter({ key: 123 }));
 
   const configService = new ConfigService(config$, defaultEnv, logger);
+  configService.preSetup(stringSchemaFor('key'));
+
   const configs = configService.atPath('key', ExampleClassWithStringSchema);
 
   try {
@@ -62,6 +73,7 @@ test('throws if config at path does not match schema', async () => {
 test("returns undefined if fetching optional config at a path that doesn't exist", async () => {
   const config$ = new BehaviorSubject(new ObjectToConfigAdapter({ foo: 'bar' }));
   const configService = new ConfigService(config$, defaultEnv, logger);
+  configService.preSetup(stringSchemaFor('unique-name'));
 
   const configs = configService.optionalAtPath('unique-name', ExampleClassWithStringSchema);
   const exampleConfig = await configs.pipe(first()).toPromise();
@@ -72,6 +84,7 @@ test("returns undefined if fetching optional config at a path that doesn't exist
 test('returns observable config at optional path if it exists', async () => {
   const config$ = new BehaviorSubject(new ObjectToConfigAdapter({ value: 'bar' }));
   const configService = new ConfigService(config$, defaultEnv, logger);
+  configService.preSetup(stringSchemaFor('value'));
 
   const configs = configService.optionalAtPath('value', ExampleClassWithStringSchema);
   const exampleConfig: any = await configs.pipe(first()).toPromise();
@@ -83,6 +96,7 @@ test('returns observable config at optional path if it exists', async () => {
 test("does not push new configs when reloading if config at path hasn't changed", async () => {
   const config$ = new BehaviorSubject(new ObjectToConfigAdapter({ key: 'value' }));
   const configService = new ConfigService(config$, defaultEnv, logger);
+  configService.preSetup(stringSchemaFor('key'));
 
   const valuesReceived: any[] = [];
   configService.atPath('key', ExampleClassWithStringSchema).subscribe(config => {
@@ -97,6 +111,7 @@ test("does not push new configs when reloading if config at path hasn't changed"
 test('pushes new config when reloading and config at path has changed', async () => {
   const config$ = new BehaviorSubject(new ObjectToConfigAdapter({ key: 'value' }));
   const configService = new ConfigService(config$, defaultEnv, logger);
+  configService.preSetup(stringSchemaFor('key'));
 
   const valuesReceived: any[] = [];
   configService.atPath('key', ExampleClassWithStringSchema).subscribe(config => {
@@ -108,21 +123,29 @@ test('pushes new config when reloading and config at path has changed', async ()
   expect(valuesReceived).toEqual(['value', 'new value']);
 });
 
-test("throws error if config class does not implement 'schema'", async () => {
-  expect.assertions(1);
-
+test('throws error if reads config before schema is set', async () => {
   class ExampleClass {}
 
   const config$ = new BehaviorSubject(new ObjectToConfigAdapter({ key: 'value' }));
   const configService = new ConfigService(config$, defaultEnv, logger);
+  const configs = configService.atPath('key', ExampleClass as any);
+
+  expect(configs.pipe(first()).toPromise()).rejects.toMatchInlineSnapshot(
+    `[Error: No validation schema has been defined]`
+  );
+});
 
+test("throws error if 'schema' is not defined for a key", async () => {
+  class ExampleClass {}
+
+  const config$ = new BehaviorSubject(new ObjectToConfigAdapter({ key: 'value' }));
+  const configService = new ConfigService(config$, defaultEnv, logger);
+  configService.preSetup(stringSchemaFor('no-key'));
   const configs = configService.atPath('key', ExampleClass as any);
 
-  try {
-    await configs.pipe(first()).toPromise();
-  } catch (e) {
-    expect(e).toMatchSnapshot();
-  }
+  expect(configs.pipe(first()).toPromise()).rejects.toMatchInlineSnapshot(
+    `[Error: No config schema defined for key]`
+  );
 });
 
 test('tracks unhandled paths', async () => {
@@ -178,28 +201,26 @@ test('correctly passes context', async () => {
   const env = new Env('/kibana', getEnvOptions());
 
   const config$ = new BehaviorSubject(new ObjectToConfigAdapter({ foo: {} }));
+  const schemaDefinition = schema.object({
+    branchRef: schema.string({
+      defaultValue: schema.contextRef('branch'),
+    }),
+    buildNumRef: schema.number({
+      defaultValue: schema.contextRef('buildNum'),
+    }),
+    buildShaRef: schema.string({
+      defaultValue: schema.contextRef('buildSha'),
+    }),
+    devRef: schema.boolean({ defaultValue: schema.contextRef('dev') }),
+    prodRef: schema.boolean({ defaultValue: schema.contextRef('prod') }),
+    versionRef: schema.string({
+      defaultValue: schema.contextRef('version'),
+    }),
+  });
   const configService = new ConfigService(config$, env, logger);
-  const configs = configService.atPath(
-    'foo',
-    createClassWithSchema(
-      schema.object({
-        branchRef: schema.string({
-          defaultValue: schema.contextRef('branch'),
-        }),
-        buildNumRef: schema.number({
-          defaultValue: schema.contextRef('buildNum'),
-        }),
-        buildShaRef: schema.string({
-          defaultValue: schema.contextRef('buildSha'),
-        }),
-        devRef: schema.boolean({ defaultValue: schema.contextRef('dev') }),
-        prodRef: schema.boolean({ defaultValue: schema.contextRef('prod') }),
-        versionRef: schema.string({
-          defaultValue: schema.contextRef('version'),
-        }),
-      })
-    )
-  );
+  configService.preSetup(new Map([['foo', schemaDefinition]]));
+
+  const configs = configService.atPath('foo', createClassWithSchema(schemaDefinition));
 
   expect(await configs.pipe(first()).toPromise()).toMatchSnapshot();
 });
@@ -278,9 +299,3 @@ function createClassWithSchema(s: Type<any>) {
     constructor(readonly value: TypeOf<typeof s>) {}
   };
 }
-
-class ExampleClassWithStringSchema {
-  public static schema = schema.string();
-
-  constructor(readonly value: string) {}
-}

src/core/server/config/config_service.ts

@@ -34,6 +34,7 @@ export class ConfigService {
    * then list all unhandled config paths when the startup process is completed.
    */
   private readonly handledPaths: ConfigPath[] = [];
+  private schemas?: Map<string, Type<any>>;
 
   constructor(
     private readonly config$: Observable<Config>,
@@ -42,6 +43,21 @@ export class ConfigService {
   ) {
     this.log = logger.get('config');
   }
+  /**
+   * Defines a validation schema for an appropriate path in config object.
+   * Performs validation for initial values.
+   * @internal
+   */
+  public async preSetup(schemas: Map<ConfigPath, Type<any>>) {
+    this.schemas = new Map();
+    for (const [path, schema] of schemas) {
+      const namespace = pathToString(path);
+      this.schemas.set(namespace, schema);
+      await this.getValidatedConfig(namespace)
+        .pipe(first())
+        .toPromise();
+    }
+  }
 
   /**
    * Returns the full config object observable. This is not intended for
@@ -63,8 +79,8 @@ export class ConfigService {
     path: ConfigPath,
     ConfigClass: ConfigWithSchema<TSchema, TConfig>
   ) {
-    return this.getDistinctConfig(path).pipe(
-      map(config => this.createConfig(path, config, ConfigClass))
+    return this.getValidatedConfig(path).pipe(
+      map(config => this.createConfig(config, ConfigClass))
     );
   }
 
@@ -79,9 +95,7 @@ export class ConfigService {
     ConfigClass: ConfigWithSchema<TSchema, TConfig>
   ) {
     return this.getDistinctConfig(path).pipe(
-      map(config =>
-        config === undefined ? undefined : this.createConfig(path, config, ConfigClass)
-      )
+      map(config => (config === undefined ? undefined : this.createConfig(config, ConfigClass)))
     );
   }
 
@@ -122,24 +136,16 @@ export class ConfigService {
     return config.getFlattenedPaths().filter(path => isPathHandled(path, handledPaths));
   }
 
-  private createConfig<TSchema extends Type<any>, TConfig>(
-    path: ConfigPath,
-    config: Record<string, any>,
-    ConfigClass: ConfigWithSchema<TSchema, TConfig>
-  ) {
-    const namespace = Array.isArray(path) ? path.join('.') : path;
-
-    const configSchema = ConfigClass.schema;
-
-    if (configSchema === undefined || typeof configSchema.validate !== 'function') {
-      throw new Error(
-        `The config class [${
-          ConfigClass.name
-        }] did not contain a static 'schema' field, which is required when creating a config instance`
-      );
+  private validateConfig(path: ConfigPath, config: Record<string, any>) {
+    if (!this.schemas) {
+      throw new Error('No validation schema has been defined');
     }
-
-    const validatedConfig = ConfigClass.schema.validate(
+    const namespace = pathToString(path);
+    const schema = this.schemas.get(namespace);
+    if (!schema) {
+      throw new Error(`No config schema defined for ${namespace}`);
+    }
+    const validatedConfig = schema.validate(
       config,
       {
         dev: this.env.mode.dev,
@@ -148,9 +154,21 @@ export class ConfigService {
       },
       namespace
     );
+
+    return validatedConfig;
+  }
+
+  private createConfig<TSchema extends Type<any>, TConfig>(
+    validatedConfig: Record<string, any>,
+    ConfigClass: ConfigWithSchema<TSchema, TConfig>
+  ) {
     return new ConfigClass(validatedConfig, this.env);
   }
 
+  private getValidatedConfig(path: ConfigPath) {
+    return this.getDistinctConfig(path).pipe(map(config => this.validateConfig(path, config)));
+  }
+
   private getDistinctConfig(path: ConfigPath) {
     this.markAsHandled(path);
 

src/core/server/dev/dev_config.ts

@@ -25,8 +25,12 @@ const createDevSchema = schema.object({
   }),
 });
 
-type DevConfigType = TypeOf<typeof createDevSchema>;
+export const configDefinition = {
+  configPath: 'dev',
+  schema: createDevSchema,
+};
 
+export type DevConfigType = TypeOf<typeof createDevSchema>;
 export class DevConfig {
   /**
    * @internal

src/core/server/dev/index.ts

@@ -17,4 +17,4 @@
  * under the License.
  */
 
-export { DevConfig } from './dev_config';
+export { DevConfig, configDefinition } from './dev_config';

src/core/server/elasticsearch/elasticsearch_config.ts

@@ -62,6 +62,13 @@ const configSchema = schema.object({
 
 type SslConfigSchema = TypeOf<typeof configSchema>['ssl'];
 
+export type ElasticsearchConfigType = TypeOf<typeof configSchema>;
+
+export const configDefinition = {
+  configPath: 'elasticsearch',
+  schema: configSchema,
+};
+
 export class ElasticsearchConfig {
   public static schema = configSchema;
 

src/core/server/elasticsearch/elasticsearch_service.test.ts

@@ -22,32 +22,34 @@ import { first } from 'rxjs/operators';
 import { MockClusterClient } from './elasticsearch_service.test.mocks';
 
 import { BehaviorSubject, combineLatest } from 'rxjs';
-import { Config, ConfigService, Env, ObjectToConfigAdapter } from '../config';
+import { Env } from '../config';
 import { getEnvOptions } from '../config/__mocks__/env';
 import { CoreContext } from '../core_context';
+import { configServiceMock } from '../config/config_service.mock';
 import { loggingServiceMock } from '../logging/logging_service.mock';
 import { ElasticsearchConfig } from './elasticsearch_config';
 import { ElasticsearchService } from './elasticsearch_service';
 
 let elasticsearchService: ElasticsearchService;
-let configService: ConfigService;
+const configService = configServiceMock.create();
+configService.atPath.mockReturnValue(
+  new BehaviorSubject(
+    new ElasticsearchConfig({
+      hosts: ['http://1.2.3.4'],
+      username: 'jest',
+      healthCheck: {},
+      ssl: {},
+    } as any)
+  )
+);
+
 let env: Env;
 let coreContext: CoreContext;
 const logger = loggingServiceMock.create();
 beforeEach(() => {
   env = Env.createDefault(getEnvOptions());
 
-  configService = new ConfigService(
-    new BehaviorSubject<Config>(
-      new ObjectToConfigAdapter({
-        elasticsearch: { hosts: ['http://1.2.3.4'], username: 'jest' },
-      })
-    ),
-    env,
-    logger
-  );
-
-  coreContext = { env, logger, configService };
+  coreContext = { env, logger, configService: configService as any };
   elasticsearchService = new ElasticsearchService(coreContext);
 });
 

src/core/server/elasticsearch/index.ts

@@ -21,3 +21,4 @@ export { ElasticsearchServiceSetup, ElasticsearchService } from './elasticsearch
 export { CallAPIOptions, ClusterClient } from './cluster_client';
 export { ScopedClusterClient, Headers, APICaller } from './scoped_cluster_client';
 export { ElasticsearchClientConfig } from './elasticsearch_client_config';
+export { configDefinition } from './elasticsearch_config';

src/core/server/http/http_config.ts

@@ -85,6 +85,11 @@ const createHttpSchema = schema.object(
 
 export type HttpConfigType = TypeOf<typeof createHttpSchema>;
 
+export const configDefinition = {
+  configPath: 'server',
+  schema: createHttpSchema,
+};
+
 export class HttpConfig {
   /**
    * @internal