Add a stub endpoint plugin

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

@@ -55,7 +55,7 @@ test('throws if config at path does not match schema', async () => {
   await expect(
     configService.setSchema('key', schema.string())
   ).rejects.toThrowErrorMatchingInlineSnapshot(
-    `"[key]: expected value of type [string] but got [number]"`
+    `"[config validation of [key]]: expected value of type [string] but got [number]"`
   );
 });
 
@@ -78,11 +78,11 @@ test('re-validate config when updated', async () => {
   config$.next(new ObjectToConfigAdapter({ key: 123 }));
 
   await expect(valuesReceived).toMatchInlineSnapshot(`
-Array [
-  "value",
-  [Error: [key]: expected value of type [string] but got [number]],
-]
-`);
+    Array [
+      "value",
+      [Error: [config validation of [key]]: expected value of type [string] but got [number]],
+    ]
+  `);
 });
 
 test("returns undefined if fetching optional config at a path that doesn't exist", async () => {
@@ -143,7 +143,7 @@ test("throws error if 'schema' is not defined for a key", async () => {
   const configs = configService.atPath('key');
 
   await expect(configs.pipe(first()).toPromise()).rejects.toMatchInlineSnapshot(
-    `[Error: No validation schema has been defined for key]`
+    `[Error: No validation schema has been defined for [key]]`
   );
 });
 
@@ -153,7 +153,7 @@ test("throws error if 'setSchema' called several times for the same key", async
   const addSchema = async () => await configService.setSchema('key', schema.string());
   await addSchema();
   await expect(addSchema()).rejects.toMatchInlineSnapshot(
-    `[Error: Validation schema for key was already registered.]`
+    `[Error: Validation schema for [key] was already registered.]`
   );
 });
 
@@ -280,6 +280,33 @@ test('handles disabled path and marks config as used', async () => {
   expect(unusedPaths).toEqual([]);
 });
 
+test('does not throw if schema does not define "enabled" schema', async () => {
+  const initialConfig = {
+    pid: {
+      file: '/some/file.pid',
+    },
+  };
+
+  const config$ = new BehaviorSubject(new ObjectToConfigAdapter(initialConfig));
+  const configService = new ConfigService(config$, defaultEnv, logger);
+  expect(
+    configService.setSchema(
+      'pid',
+      schema.object({
+        file: schema.string(),
+      })
+    )
+  ).resolves.toBeUndefined();
+
+  const value$ = configService.atPath('pid');
+  const value: any = await value$.pipe(first()).toPromise();
+  expect(value.enabled).toBe(undefined);
+
+  const valueOptional$ = configService.optionalAtPath('pid');
+  const valueOptional: any = await valueOptional$.pipe(first()).toPromise();
+  expect(valueOptional.enabled).toBe(undefined);
+});
+
 test('treats config as enabled if config path is not present in config', async () => {
   const initialConfig = {};
 
@@ -292,3 +319,45 @@ test('treats config as enabled if config path is not present in config', async (
   const unusedPaths = await configService.getUnusedPaths();
   expect(unusedPaths).toEqual([]);
 });
+
+test('read "enabled" even if its schema is not present', async () => {
+  const initialConfig = {
+    foo: {
+      enabled: true,
+    },
+  };
+
+  const config$ = new BehaviorSubject(new ObjectToConfigAdapter(initialConfig));
+  const configService = new ConfigService(config$, defaultEnv, logger);
+
+  const isEnabled = await configService.isEnabledAtPath('foo');
+  expect(isEnabled).toBe(true);
+});
+
+test('allows plugins to specify "enabled" flag via validation schema', async () => {
+  const initialConfig = {};
+
+  const config$ = new BehaviorSubject(new ObjectToConfigAdapter(initialConfig));
+  const configService = new ConfigService(config$, defaultEnv, logger);
+
+  await configService.setSchema(
+    'foo',
+    schema.object({ enabled: schema.boolean({ defaultValue: false }) })
+  );
+
+  expect(await configService.isEnabledAtPath('foo')).toBe(false);
+
+  await configService.setSchema(
+    'bar',
+    schema.object({ enabled: schema.boolean({ defaultValue: true }) })
+  );
+
+  expect(await configService.isEnabledAtPath('bar')).toBe(true);
+
+  await configService.setSchema(
+    'baz',
+    schema.object({ different: schema.boolean({ defaultValue: true }) })
+  );
+
+  expect(await configService.isEnabledAtPath('baz')).toBe(true);
+});

src/core/server/config/config_service.ts

@@ -54,7 +54,7 @@ export class ConfigService {
   public async setSchema(path: ConfigPath, schema: Type<unknown>) {
     const namespace = pathToString(path);
     if (this.schemas.has(namespace)) {
-      throw new Error(`Validation schema for ${path} was already registered.`);
+      throw new Error(`Validation schema for [${path}] was already registered.`);
     }
 
     this.schemas.set(namespace, schema);
@@ -98,14 +98,28 @@ export class ConfigService {
   }
 
   public async isEnabledAtPath(path: ConfigPath) {
-    const enabledPath = createPluginEnabledPath(path);
+    const namespace = pathToString(path);
+
+    const validatedConfig = this.schemas.has(namespace)
+      ? await this.atPath<{ enabled?: boolean }>(path)
+          .pipe(first())
+          .toPromise()
+      : undefined;
 
+    const enabledPath = createPluginEnabledPath(path);
     const config = await this.config$.pipe(first()).toPromise();
-    if (!config.has(enabledPath)) {
+
+    // if plugin hasn't got a config schema, we try to read "enabled" directly
+    const isEnabled =
+      validatedConfig && validatedConfig.enabled !== undefined
+        ? validatedConfig.enabled
+        : config.get(enabledPath);
+
+    // not declared. consider that plugin is enabled by default
+    if (isEnabled === undefined) {
       return true;
     }
 
-    const isEnabled = config.get(enabledPath);
     if (isEnabled === false) {
       // If the plugin is _not_ enabled, we mark the entire plugin path as
       // handled, as it's expected that it won't be used.
@@ -138,7 +152,7 @@ export class ConfigService {
     const namespace = pathToString(path);
     const schema = this.schemas.get(namespace);
     if (!schema) {
-      throw new Error(`No validation schema has been defined for ${namespace}`);
+      throw new Error(`No validation schema has been defined for [${namespace}]`);
     }
     return schema.validate(
       config,
@@ -147,7 +161,7 @@ export class ConfigService {
         prod: this.env.mode.prod,
         ...this.env.packageInfo,
       },
-      namespace
+      `config validation of [${namespace}]`
     );
   }
 

x-pack/plugins/endpoint/kibana.json

@@ -0,0 +1,8 @@
+{
+  "id": "endpoint",
+  "version": "1.0.0",
+  "kibanaVersion": "kibana",
+  "configPath": ["x-pack", "endpoint"],
+  "server": true,
+  "ui": true
+}

x-pack/plugins/endpoint/public/applications/endpoint/index.tsx

@@ -0,0 +1,26 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import * as React from 'react';
+import ReactDOM from 'react-dom';
+import { AppMountContext, AppMountParameters } from 'kibana/public';
+
+/**
+ * This module will be loaded asynchronously to reduce the bundle size of your plugin's main bundle.
+ */
+export function renderApp(appMountContext: AppMountContext, { element }: AppMountParameters) {
+  appMountContext.core.http.get('/endpoint/hello-world');
+
+  ReactDOM.render(<AppRoot />, element);
+
+  return function() {
+    ReactDOM.unmountComponentAtNode(element);
+  };
+}
+
+const AppRoot = React.memo(function Root() {
+  return <h1>Welcome to Endpoint</h1>;
+});

x-pack/plugins/endpoint/public/index.ts

@@ -0,0 +1,15 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { PluginInitializer } from 'kibana/public';
+import { schema } from '@kbn/config-schema';
+import { EndpointPlugin } from './plugin';
+
+export const config = {
+  schema: schema.object({ enabled: schema.boolean({ defaultValue: false }) }),
+};
+
+export const plugin: PluginInitializer<{}, {}> = () => new EndpointPlugin();

x-pack/plugins/endpoint/public/plugin.ts

@@ -0,0 +1,27 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { Plugin, CoreSetup } from 'kibana/public';
+
+export class EndpointPlugin implements Plugin<{}, {}> {
+  public setup(core: CoreSetup) {
+    core.application.register({
+      id: 'endpoint',
+      title: 'Endpoint',
+      async mount(context, params) {
+        const { renderApp } = await import('./applications/endpoint');
+        return renderApp(context, params);
+      },
+    });
+    return {};
+  }
+
+  public start() {
+    return {};
+  }
+
+  public stop() {}
+}

x-pack/plugins/endpoint/server/index.ts

@@ -0,0 +1,16 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { schema } from '@kbn/config-schema';
+import { EndpointPlugin } from './plugin';
+
+export const config = {
+  schema: schema.object({ enabled: schema.boolean({ defaultValue: false }) }),
+};
+
+export function plugin() {
+  return new EndpointPlugin();
+}

x-pack/plugins/endpoint/server/plugin.ts

@@ -0,0 +1,18 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { Plugin, CoreSetup } from 'kibana/server';
+import { addRoutes } from './routes';
+
+export class EndpointPlugin implements Plugin {
+  public setup(core: CoreSetup) {
+    const router = core.http.createRouter();
+    addRoutes(router);
+  }
+
+  public start() {}
+  public stop() {}
+}

x-pack/plugins/endpoint/server/routes/index.ts

@@ -0,0 +1,27 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { IRouter, KibanaResponseFactory } from 'kibana/server';
+
+export function addRoutes(router: IRouter) {
+  router.get(
+    {
+      path: '/endpoint/hello-world',
+      validate: false,
+    },
+    greetingIndex
+  );
+}
+
+async function greetingIndex(...passedArgs: [unknown, unknown, KibanaResponseFactory]) {
+  const [, , response] = passedArgs;
+  return response.ok({
+    body: JSON.stringify({ hello: 'world' }),
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  });
+}