Console to NP ready

rfcs/text/0004_application_service_mounting.md

@@ -39,7 +39,7 @@ class MyPlugin {
       id: 'my-app',
       title: 'My Application',
       async mount(context, targetDomElement) {
-        const { renderApp } = await import('./applcation');
+        const { renderApp } = await import('./application');
         return renderApp(context, targetDomElement);
       }
     });
@@ -260,7 +260,7 @@ export class MyPlugin {
     application.register({
       id: 'my-app',
       async mount(context, targetDomElem) {
-        const { renderApp } = await import('./applcation');
+        const { renderApp } = await import('./application');
         return renderApp(context, targetDomElement);
       }
     });

src/legacy/core_plugins/console/index.js → src/legacy/core_plugins/console/index.ts

@@ -23,18 +23,17 @@ import { resolve, join, sep } from 'path';
 import url from 'url';
 import { has, isEmpty, head, pick } from 'lodash';
 
-import { resolveApi } from './api_server/server';
-import { addExtensionSpecFilePath } from './api_server/spec';
+// @ts-ignore
+import { resolveApi } from './server/api_server/server';
+// @ts-ignore
+import { addExtensionSpecFilePath } from './server/api_server/spec';
+// @ts-ignore
 import { setHeaders } from './server/set_headers';
+// @ts-ignore
+import { ProxyConfigCollection, getElasticsearchProxyConfig, createProxyRoute } from './server';
 
-import {
-  ProxyConfigCollection,
-  getElasticsearchProxyConfig,
-  createProxyRoute
-} from './server';
-
-function filterHeaders(originalHeaders, headersToKeep) {
-  const normalizeHeader = function (header) {
+function filterHeaders(originalHeaders: any, headersToKeep: any) {
+  const normalizeHeader = function(header: any) {
     if (!header) {
       return '';
     }
@@ -48,51 +47,64 @@ function filterHeaders(originalHeaders, headersToKeep) {
   return pick(originalHeaders, headersToKeepNormalized);
 }
 
-export default function (kibana) {
+// eslint-disable-next-line
+export default function(kibana: any) {
   const modules = resolve(__dirname, 'public/webpackShims/');
-  const src = resolve(__dirname, 'public/src/');
+  const quarantinedSrc = resolve(__dirname, 'public/quarantined/src/');
+  const src = resolve(__dirname, 'public/np_ready/public');
 
-  let defaultVars;
-  const apps = [];
+  let defaultVars: any;
+  const apps: any[] = [];
   return new kibana.Plugin({
     id: 'console',
     require: ['elasticsearch'],
 
-    config: function (Joi) {
+    config(Joi: any) {
       return Joi.object({
         enabled: Joi.boolean().default(true),
-        proxyFilter: Joi.array().items(Joi.string()).single().default(['.*']),
+        proxyFilter: Joi.array()
+          .items(Joi.string())
+          .single()
+          .default(['.*']),
         ssl: Joi.object({
           verify: Joi.boolean(),
         }).default(),
-        proxyConfig: Joi.array().items(
-          Joi.object().keys({
-            match: Joi.object().keys({
-              protocol: Joi.string().default('*'),
-              host: Joi.string().default('*'),
-              port: Joi.string().default('*'),
-              path: Joi.string().default('*')
-            }),
-
-            timeout: Joi.number(),
-            ssl: Joi.object().keys({
-              verify: Joi.boolean(),
-              ca: Joi.array().single().items(Joi.string()),
-              cert: Joi.string(),
-              key: Joi.string()
-            }).default()
-          })
-        ).default()
+        proxyConfig: Joi.array()
+          .items(
+            Joi.object().keys({
+              match: Joi.object().keys({
+                protocol: Joi.string().default('*'),
+                host: Joi.string().default('*'),
+                port: Joi.string().default('*'),
+                path: Joi.string().default('*'),
+              }),
+
+              timeout: Joi.number(),
+              ssl: Joi.object()
+                .keys({
+                  verify: Joi.boolean(),
+                  ca: Joi.array()
+                    .single()
+                    .items(Joi.string()),
+                  cert: Joi.string(),
+                  key: Joi.string(),
+                })
+                .default(),
+            })
+          )
+          .default(),
       }).default();
     },
 
-    deprecations: function () {
+    deprecations() {
       return [
-        (settings, log) => {
+        (settings: any, log: any) => {
           if (has(settings, 'proxyConfig')) {
-            log('Config key "proxyConfig" is deprecated. Configuration can be inferred from the "elasticsearch" settings');
+            log(
+              'Config key "proxyConfig" is deprecated. Configuration can be inferred from the "elasticsearch" settings'
+            );
           }
-        }
+        },
       ];
     },
 
@@ -105,71 +117,78 @@ export default function (kibana) {
       };
     },
 
-    async init(server, options) {
+    async init(server: any, options: any) {
       server.expose('addExtensionSpecFilePath', addExtensionSpecFilePath);
       if (options.ssl && options.ssl.verify) {
         throw new Error('sense.ssl.verify is no longer supported.');
       }
 
       const config = server.config();
-      const legacyEsConfig = await server.newPlatform.setup.core.elasticsearch.legacy.config$.pipe(first()).toPromise();
+      const legacyEsConfig = await server.newPlatform.setup.core.elasticsearch.legacy.config$
+        .pipe(first())
+        .toPromise();
       const proxyConfigCollection = new ProxyConfigCollection(options.proxyConfig);
-      const proxyPathFilters = options.proxyFilter.map(str => new RegExp(str));
+      const proxyPathFilters = options.proxyFilter.map((str: string) => new RegExp(str));
 
       defaultVars = {
         elasticsearchUrl: url.format(
           Object.assign(url.parse(head(legacyEsConfig.hosts)), { auth: false })
         ),
       };
 
-      server.route(createProxyRoute({
-        baseUrl: head(legacyEsConfig.hosts),
-        pathFilters: proxyPathFilters,
-        getConfigForReq(req, uri) {
-          const filteredHeaders = filterHeaders(req.headers, legacyEsConfig.requestHeadersWhitelist);
-          const headers = setHeaders(filteredHeaders, legacyEsConfig.customHeaders);
+      server.route(
+        createProxyRoute({
+          baseUrl: head(legacyEsConfig.hosts),
+          pathFilters: proxyPathFilters,
+          getConfigForReq(req: any, uri: any) {
+            const filteredHeaders = filterHeaders(
+              req.headers,
+              legacyEsConfig.requestHeadersWhitelist
+            );
+            const headers = setHeaders(filteredHeaders, legacyEsConfig.customHeaders);
+
+            if (!isEmpty(config.get('console.proxyConfig'))) {
+              return {
+                ...proxyConfigCollection.configForUri(uri),
+                headers,
+              };
+            }
 
-          if (!isEmpty(config.get('console.proxyConfig'))) {
             return {
-              ...proxyConfigCollection.configForUri(uri),
+              ...getElasticsearchProxyConfig(legacyEsConfig),
               headers,
             };
-          }
-
-          return {
-            ...getElasticsearchProxyConfig(legacyEsConfig),
-            headers,
-          };
-        }
-      }));
+          },
+        })
+      );
 
       server.route({
         path: '/api/console/api_server',
         method: ['GET', 'POST'],
-        handler: function (req, h) {
+        handler(req: any, h: any) {
           const { sense_version: version, apis } = req.query;
           if (!apis) {
             throw Boom.badRequest('"apis" is a required param.');
           }
 
           return resolveApi(version, apis.split(','), h);
-        }
+        },
       });
     },
 
     uiExports: {
-      apps: apps,
-      hacks: ['plugins/console/hacks/register'],
-      devTools: ['plugins/console/console'],
-      styleSheetPaths: resolve(__dirname, 'public/index.scss'),
+      apps,
+      hacks: ['plugins/console/quarantined/hacks/register'],
+      devTools: [`${src}/legacy`],
+      styleSheetPaths: resolve(__dirname, 'public/quarantined/index.scss'),
 
       injectDefaultVars: () => defaultVars,
 
       noParse: [
         join(modules, 'ace' + sep),
         join(modules, 'moment_src/moment' + sep),
-        join(src, 'sense_editor/mode/worker.js')
-      ]
-    }
-  });
+        join(quarantinedSrc, 'sense_editor/mode/worker.js'),
+      ],
+    },
+  } as any);
 }

src/legacy/core_plugins/console/public/README.md

@@ -0,0 +1,20 @@
+## New Platform (NP) Ready vs Quarantined
+
+We want to move toward more modularised code in the Console app.
+Part of the effort means separating out different console compoonents
+like:
+
+- The language parser
+- The editor rendering component
+- Autocomplete
+- The UI container components
+
+In addition to this effort we want to bring Console in line with NP
+requirements and ensure that we are not using NG in this app anymore.
+
+The quarantined folder contains all of the code that has been cleared
+for living in the new platform as it has not been properly refactored
+or has dependencies on, for example, UI public.
+
+Over time, the quarantined part of the code should shrink to nothing
+and we should only have NP ready code.

src/legacy/core_plugins/console/public/np_ready/kibana.json

@@ -0,0 +1,6 @@
+{
+  "id": "console",
+  "version": "kibana",
+  "server": true,
+  "ui": true
+}