rename configDefinition

src/core/server/dev/dev_config.ts

@@ -25,8 +25,8 @@ const createDevSchema = schema.object({
   }),
 });
 
-export const configDefinition = {
-  configPath: 'dev',
+export const config = {
+  path: 'dev',
   schema: createDevSchema,
 };
 
@@ -42,7 +42,7 @@ export class DevConfig {
   /**
    * @internal
    */
-  constructor(config: DevConfigType) {
-    this.basePathProxyTargetPort = config.basePathProxyTarget;
+  constructor(rawConfig: DevConfigType) {
+    this.basePathProxyTargetPort = rawConfig.basePathProxyTarget;
   }
 }

src/core/server/dev/index.ts

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

src/core/server/elasticsearch/elasticsearch_config.ts

@@ -64,8 +64,8 @@ type SslConfigSchema = TypeOf<typeof configSchema>['ssl'];
 
 export type ElasticsearchConfigType = TypeOf<typeof configSchema>;
 
-export const configDefinition = {
-  configPath: 'elasticsearch',
+export const config = {
+  path: 'elasticsearch',
   schema: configSchema,
 };
 
@@ -163,32 +163,32 @@ export class ElasticsearchConfig {
    */
   public readonly customHeaders: TypeOf<typeof configSchema>['customHeaders'];
 
-  constructor(config: TypeOf<typeof configSchema>) {
-    this.apiVersion = config.apiVersion;
-    this.logQueries = config.logQueries;
-    this.hosts = Array.isArray(config.hosts) ? config.hosts : [config.hosts];
-    this.requestHeadersWhitelist = Array.isArray(config.requestHeadersWhitelist)
-      ? config.requestHeadersWhitelist
-      : [config.requestHeadersWhitelist];
-    this.pingTimeout = config.pingTimeout;
-    this.requestTimeout = config.requestTimeout;
-    this.shardTimeout = config.shardTimeout;
-    this.sniffOnStart = config.sniffOnStart;
-    this.sniffOnConnectionFault = config.sniffOnConnectionFault;
-    this.sniffInterval = config.sniffInterval;
-    this.healthCheckDelay = config.healthCheck.delay;
-    this.username = config.username;
-    this.password = config.password;
-    this.customHeaders = config.customHeaders;
-
-    const certificateAuthorities = Array.isArray(config.ssl.certificateAuthorities)
-      ? config.ssl.certificateAuthorities
-      : typeof config.ssl.certificateAuthorities === 'string'
-      ? [config.ssl.certificateAuthorities]
+  constructor(rawConfig: TypeOf<typeof configSchema>) {
+    this.apiVersion = rawConfig.apiVersion;
+    this.logQueries = rawConfig.logQueries;
+    this.hosts = Array.isArray(rawConfig.hosts) ? rawConfig.hosts : [rawConfig.hosts];
+    this.requestHeadersWhitelist = Array.isArray(rawConfig.requestHeadersWhitelist)
+      ? rawConfig.requestHeadersWhitelist
+      : [rawConfig.requestHeadersWhitelist];
+    this.pingTimeout = rawConfig.pingTimeout;
+    this.requestTimeout = rawConfig.requestTimeout;
+    this.shardTimeout = rawConfig.shardTimeout;
+    this.sniffOnStart = rawConfig.sniffOnStart;
+    this.sniffOnConnectionFault = rawConfig.sniffOnConnectionFault;
+    this.sniffInterval = rawConfig.sniffInterval;
+    this.healthCheckDelay = rawConfig.healthCheck.delay;
+    this.username = rawConfig.username;
+    this.password = rawConfig.password;
+    this.customHeaders = rawConfig.customHeaders;
+
+    const certificateAuthorities = Array.isArray(rawConfig.ssl.certificateAuthorities)
+      ? rawConfig.ssl.certificateAuthorities
+      : typeof rawConfig.ssl.certificateAuthorities === 'string'
+      ? [rawConfig.ssl.certificateAuthorities]
       : undefined;
 
     this.ssl = {
-      ...config.ssl,
+      ...rawConfig.ssl,
       certificateAuthorities,
     };
   }

src/core/server/elasticsearch/index.ts

@@ -21,4 +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';
+export { config } from './elasticsearch_config';

src/core/server/http/http_config.ts

@@ -85,8 +85,8 @@ const createHttpSchema = schema.object(
 
 export type HttpConfigType = TypeOf<typeof createHttpSchema>;
 
-export const configDefinition = {
-  configPath: 'server',
+export const config = {
+  path: 'server',
   schema: createHttpSchema,
 };
 
@@ -109,15 +109,15 @@ export class HttpConfig {
   /**
    * @internal
    */
-  constructor(config: HttpConfigType, env: Env) {
-    this.autoListen = config.autoListen;
-    this.host = config.host;
-    this.port = config.port;
-    this.cors = config.cors;
-    this.maxPayload = config.maxPayload;
-    this.basePath = config.basePath;
-    this.rewriteBasePath = config.rewriteBasePath;
+  constructor(rawConfig: HttpConfigType, env: Env) {
+    this.autoListen = rawConfig.autoListen;
+    this.host = rawConfig.host;
+    this.port = rawConfig.port;
+    this.cors = rawConfig.cors;
+    this.maxPayload = rawConfig.maxPayload;
+    this.basePath = rawConfig.basePath;
+    this.rewriteBasePath = rawConfig.rewriteBasePath;
     this.publicDir = env.staticFilesDir;
-    this.ssl = new SslConfig(config.ssl);
+    this.ssl = new SslConfig(rawConfig.ssl);
   }
 }

src/core/server/http/http_service.test.ts

@@ -22,7 +22,7 @@ import { mockHttpServer } from './http_service.test.mocks';
 import { noop } from 'lodash';
 import { BehaviorSubject } from 'rxjs';
 import { HttpService, Router } from '.';
-import { HttpConfigType, configDefinition } from './http_config';
+import { HttpConfigType, config } from './http_config';
 import { Config, ConfigService, Env, ObjectToConfigAdapter } from '../config';
 import { loggingServiceMock } from '../logging/logging_service.mock';
 import { getEnvOptions } from '../config/__mocks__/env';
@@ -40,7 +40,7 @@ const createConfigService = (value: Partial<HttpConfigType> = {}) => {
     env,
     logger
   );
-  configService.setSchema(configDefinition.configPath, configDefinition.schema);
+  configService.setSchema(config.path, config.schema);
   return configService;
 };
 

src/core/server/http/index.ts

@@ -17,7 +17,7 @@
  * under the License.
  */
 
-export { configDefinition, HttpConfig, HttpConfigType } from './http_config';
+export { config, HttpConfig, HttpConfigType } from './http_config';
 export { HttpService, HttpServiceSetup, HttpServiceStart } from './http_service';
 export { Router, KibanaRequest } from './router';
 export { BasePathProxyServer } from './base_path_proxy_server';

src/core/server/logging/index.ts

@@ -22,6 +22,6 @@ export { LoggerFactory } from './logger_factory';
 export { LogRecord } from './log_record';
 export { LogLevel } from './log_level';
 /** @internal */
-export { LoggingConfig, configDefinition } from './logging_config';
+export { LoggingConfig, config } from './logging_config';
 /** @internal */
 export { LoggingService } from './logging_service';

src/core/server/logging/logging_config.ts

@@ -79,8 +79,8 @@ const loggingSchema = schema.object({
 
 /** @internal */
 export type LoggerConfigType = TypeOf<typeof createLoggerSchema>;
-export const configDefinition = {
-  configPath: 'logging',
+export const config = {
+  path: 'logging',
   schema: loggingSchema,
 };
 

src/core/server/plugins/discovery/plugins_discovery.test.ts

@@ -26,7 +26,7 @@ import { Config, ConfigService, Env, ObjectToConfigAdapter } from '../../config'
 import { getEnvOptions } from '../../config/__mocks__/env';
 import { loggingServiceMock } from '../../logging/logging_service.mock';
 import { PluginWrapper } from '../plugin';
-import { PluginsConfig, configDefinition } from '../plugins_config';
+import { PluginsConfig, config } from '../plugins_config';
 import { discover } from './plugins_discovery';
 
 const TEST_PLUGIN_SEARCH_PATHS = {
@@ -121,7 +121,7 @@ test('properly iterates through plugin search locations', async () => {
     env,
     logger
   );
-  configService.setSchema(configDefinition.configPath, configDefinition.schema);
+  configService.setSchema(config.path, config.schema);
 
   const pluginsConfig = await configService
     .atPath('plugins', PluginsConfig)

src/core/server/plugins/index.ts

@@ -18,7 +18,7 @@
  */
 
 export { PluginsService, PluginsServiceSetup, PluginsServiceStart } from './plugins_service';
-export { configDefinition } from './plugins_config';
+export { config } from './plugins_config';
 /** @internal */
 export { isNewPlatformPlugin, discover } from './discovery';
 /** @internal */

src/core/server/plugins/plugin.test.ts

@@ -269,7 +269,7 @@ describe('#getConfigSchema()', () => {
     jest.doMock(
       'plugin-with-schema/server',
       () => ({
-        configDefinition: {
+        config: {
           schema: pluginSchema,
         },
       }),
@@ -284,7 +284,7 @@ describe('#getConfigSchema()', () => {
 
     expect(plugin.getConfigSchema()).toBe(pluginSchema);
   });
-  it('returns null if configDefinition not specified', () => {
+  it('returns null if config definition not specified', () => {
     jest.doMock('plugin-with-no-definition/server', () => ({}), { virtual: true });
     const manifest = createPluginManifest();
     const plugin = new PluginWrapper(
@@ -307,7 +307,7 @@ describe('#getConfigSchema()', () => {
     jest.doMock(
       'plugin-invalid-schema/server',
       () => ({
-        configDefinition: {
+        config: {
           schema: () => null,
         },
       }),

src/core/server/plugins/plugin.ts

@@ -248,16 +248,15 @@ export class PluginWrapper<
     // eslint-disable-next-line @typescript-eslint/no-var-requires
     const pluginDefinition = require(pluginPathServer);
 
-    if (!('configDefinition' in pluginDefinition)) {
-      this.log.debug(`"${pluginPathServer}" does not export "configDefinition".`);
+    if (!('config' in pluginDefinition)) {
+      this.log.debug(`"${pluginPathServer}" does not export "config".`);
       return null;
     }
 
-    const configSchema = pluginDefinition.configDefinition.schema;
-    if (!(configSchema instanceof Type)) {
+    if (!(pluginDefinition.config.schema instanceof Type)) {
       throw new Error('Configuration schema expected to be an instance of Type');
     }
-    return configSchema;
+    return pluginDefinition.config.schema;
   }
 
   private createPluginInstance() {

src/core/server/plugins/plugins_config.ts

@@ -31,8 +31,8 @@ const pluginsSchema = schema.object({
 });
 
 export type PluginsConfigType = TypeOf<typeof pluginsSchema>;
-export const configDefinition = {
-  configPath: 'plugins',
+export const config = {
+  path: 'plugins',
   schema: pluginsSchema,
 };
 
@@ -55,10 +55,10 @@ export class PluginsConfig {
    */
   public readonly additionalPluginPaths: ReadonlyArray<string>;
 
-  constructor(config: PluginsConfigType, env: Env) {
-    this.initialize = config.initialize;
+  constructor(rawConfig: PluginsConfigType, env: Env) {
+    this.initialize = rawConfig.initialize;
     this.pluginSearchPaths = env.pluginSearchPaths;
     // Only allow custom plugin paths in dev.
-    this.additionalPluginPaths = env.mode.dev ? config.paths : [];
+    this.additionalPluginPaths = env.mode.dev ? rawConfig.paths : [];
   }
 }

src/core/server/plugins/plugins_service.test.ts

@@ -31,7 +31,7 @@ import { PluginDiscoveryError } from './discovery';
 import { PluginWrapper } from './plugin';
 import { PluginsService } from './plugins_service';
 import { PluginsSystem } from './plugins_system';
-import { configDefinition } from './plugins_config';
+import { config } from './plugins_config';
 
 const MockPluginsSystem: jest.Mock<PluginsSystem> = PluginsSystem as any;
 
@@ -62,7 +62,7 @@ beforeEach(() => {
     env,
     logger
   );
-  configService.setSchema(configDefinition.configPath, configDefinition.schema);
+  configService.setSchema(config.path, config.schema);
   pluginsService = new PluginsService({ env, logger, configService });
 
   [mockPluginSystem] = MockPluginsSystem.mock.instances as any;

src/core/server/server.ts

@@ -24,12 +24,12 @@ import { ElasticsearchService } from './elasticsearch';
 import { HttpService, HttpServiceSetup, Router } from './http';
 import { LegacyService } from './legacy';
 import { Logger, LoggerFactory } from './logging';
-import { PluginsService, configDefinition as pluginsConfigDefinition } from './plugins';
+import { PluginsService, config as pluginsConfig } from './plugins';
 
-import { configDefinition as elasticsearchConfigDefinition } from './elasticsearch';
-import { configDefinition as httpConfigDefinition } from './http';
-import { configDefinition as loggingConfigDefinition } from './logging';
-import { configDefinition as devConfigDefinition } from './dev';
+import { config as elasticsearchConfig } from './elasticsearch';
+import { config as httpConfig } from './http';
+import { config as loggingConfig } from './logging';
+import { config as devConfig } from './dev';
 
 export class Server {
   public readonly configService: ConfigService;
@@ -113,11 +113,11 @@ export class Server {
 
   private async setupConfigSchemas() {
     const schemas: Array<[ConfigPath, Type<unknown>]> = [
-      [elasticsearchConfigDefinition.configPath, elasticsearchConfigDefinition.schema],
-      [loggingConfigDefinition.configPath, loggingConfigDefinition.schema],
-      [httpConfigDefinition.configPath, httpConfigDefinition.schema],
-      [pluginsConfigDefinition.configPath, pluginsConfigDefinition.schema],
-      [devConfigDefinition.configPath, devConfigDefinition.schema],
+      [elasticsearchConfig.path, elasticsearchConfig.schema],
+      [loggingConfig.path, loggingConfig.schema],
+      [httpConfig.path, httpConfig.schema],
+      [pluginsConfig.path, pluginsConfig.schema],
+      [devConfig.path, devConfig.schema],
     ];
 
     for (const [path, schema] of schemas) {

src/plugins/testbed/server/index.ts

@@ -77,6 +77,6 @@ class Plugin {
 export const plugin = (initializerContext: PluginInitializerContext) =>
   new Plugin(initializerContext);
 
-export const configDefinition = {
+export const config = {
   schema: TestBedConfig.schema,
 };