[NP] add http resources sub-service

src/core/server/http/index.ts

@@ -38,6 +38,7 @@ export {
   LifecycleResponseFactory,
   RedirectResponseOptions,
   RequestHandler,
+  RequestHandlerWrapper,
   ResponseError,
   ResponseErrorAttributes,
   ResponseHeaders,

src/core/server/http/lifecycle/on_pre_response.ts

@@ -148,7 +148,7 @@ function findHeadersIntersection(
   log: Logger
 ) {
   Object.keys(headers).forEach(headerName => {
-    if (responseHeaders[headerName] !== undefined) {
+    if (Reflect.has(responseHeaders, headerName)) {
       log.warn(`onPreResponseHandler rewrote a response header [${headerName}].`);
     }
   });

src/core/server/http/router/error_wrapper.ts

@@ -18,20 +18,10 @@
  */
 
 import Boom from 'boom';
-import { KibanaRequest } from './request';
-import { KibanaResponseFactory } from './response';
-import { RequestHandler } from './router';
-import { RequestHandlerContext } from '../../../server';
-import { RouteMethod } from './route';
+import { RequestHandlerWrapper } from './router';
 
-export const wrapErrors = <P, Q, B>(
-  handler: RequestHandler<P, Q, B, RouteMethod>
-): RequestHandler<P, Q, B, RouteMethod> => {
-  return async (
-    context: RequestHandlerContext,
-    request: KibanaRequest<P, Q, B, RouteMethod>,
-    response: KibanaResponseFactory
-  ) => {
+export const wrapErrors: RequestHandlerWrapper = handler => {
+  return async (context, request, response) => {
     try {
       return await handler(context, request, response);
     } catch (e) {

src/core/server/http/router/headers.ts

@@ -56,9 +56,9 @@ export type Headers = { [header in KnownHeaders]?: string | string[] | undefined
  * Http response headers to set.
  * @public
  */
-export type ResponseHeaders = { [header in KnownHeaders]?: string | string[] } & {
-  [header: string]: string | string[];
-};
+export type ResponseHeaders =
+  | Record<KnownHeaders, string | string[]>
+  | Record<string, string | string[]>;
 
 const normalizeHeaderField = (field: string) => field.trim().toLowerCase();
 

src/core/server/http/router/index.ts

@@ -18,7 +18,7 @@
  */
 
 export { Headers, filterHeaders, ResponseHeaders, KnownHeaders } from './headers';
-export { Router, RequestHandler, IRouter, RouteRegistrar } from './router';
+export { Router, RequestHandler, RequestHandlerWrapper, IRouter, RouteRegistrar } from './router';
 export {
   KibanaRequest,
   KibanaRequestEvents,

src/core/server/http/router/router.ts

@@ -98,7 +98,7 @@ export interface IRouter {
    * Wrap a router handler to catch and converts legacy boom errors to proper custom errors.
    * @param handler {@link RequestHandler} - a route handler to wrap
    */
-  handleLegacyErrors: <P, Q, B>(handler: RequestHandler<P, Q, B>) => RequestHandler<P, Q, B>;
+  handleLegacyErrors: RequestHandlerWrapper;
 
   /**
    * Returns all routes registered with this router.
@@ -237,9 +237,7 @@ export class Router implements IRouter {
     return [...this.routes];
   }
 
-  public handleLegacyErrors<P, Q, B>(handler: RequestHandler<P, Q, B>): RequestHandler<P, Q, B> {
-    return wrapErrors(handler);
-  }
+  public handleLegacyErrors = wrapErrors;
 
   private async handle<P, Q, B>({
     routeSchemas,
@@ -316,9 +314,33 @@ export type RequestHandler<
   P = unknown,
   Q = unknown,
   B = unknown,
-  Method extends RouteMethod = any
+  Method extends RouteMethod = any,
+  ResponseFactory extends KibanaResponseFactory = KibanaResponseFactory
 > = (
   context: RequestHandlerContext,
   request: KibanaRequest<P, Q, B, Method>,
-  response: KibanaResponseFactory
+  response: ResponseFactory
 ) => IKibanaResponse<any> | Promise<IKibanaResponse<any>>;
+
+/**
+ * Type-safe wrapper for {@link RequestHandler} function.
+ * @public
+ * @example
+ * ```typescript
+ * export const wrapper: RequestHandlerWrapper = handler => {
+ *   return async (context, request, response) => {
+ *     // do some logic
+ *     ...
+ *   };
+ * }
+ * ```
+ */
+export type RequestHandlerWrapper = <
+  P,
+  Q,
+  B,
+  Method extends RouteMethod = any,
+  ResponseFactory extends KibanaResponseFactory = KibanaResponseFactory
+>(
+  handler: RequestHandler<P, Q, B, Method, ResponseFactory>
+) => RequestHandler<P, Q, B, Method, ResponseFactory>;

src/core/server/http_resources/http_resources_service.mock.ts

@@ -0,0 +1,52 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { httpServerMock } from '../http/http_server.mocks';
+import { HttpResources, HttpResourcesServiceToolkit } from './types';
+
+const createHttpResourcesMock = (): jest.Mocked<HttpResources> => ({
+  registerCoreApp: jest.fn(),
+  registerAnonymousCoreApp: jest.fn(),
+  register: jest.fn(),
+});
+
+function createInternalHttpResourcesSetup() {
+  return {
+    createRegistrar: createHttpResourcesMock,
+  };
+}
+
+function createHttpResourcesResponseFactory() {
+  const mocked: jest.Mocked<HttpResourcesServiceToolkit> = {
+    renderCoreApp: jest.fn(),
+    renderAnonymousCoreApp: jest.fn(),
+    renderHtml: jest.fn(),
+    renderJs: jest.fn(),
+  };
+
+  return {
+    ...httpServerMock.createResponseFactory(),
+    ...mocked,
+  };
+}
+
+export const httpResourcesMock = {
+  createRegistrar: createHttpResourcesMock,
+  createSetupContract: createInternalHttpResourcesSetup,
+  createResponseFactory: createHttpResourcesResponseFactory,
+};

src/core/server/http_resources/http_resources_service.test.ts

@@ -0,0 +1,178 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { IRouter, RouteConfig } from '../http';
+
+import { coreMock } from '../mocks';
+import { mockCoreContext } from '../core_context.mock';
+import { httpServiceMock } from '../http/http_service.mock';
+import { httpServerMock } from '../http/http_server.mocks';
+import { renderingMock } from '../rendering/rendering_service.mock';
+import { HttpResourcesService, SetupDeps } from './http_resources_service';
+import { httpResourcesMock } from './http_resources_service.mock';
+
+const coreContext = mockCoreContext.create();
+
+describe('HttpResources service', () => {
+  let service: HttpResourcesService;
+  let setupDeps: SetupDeps;
+  let router: jest.Mocked<IRouter>;
+  const kibanaRequest = httpServerMock.createKibanaRequest();
+  const context = { core: coreMock.createRequestHandlerContext() };
+  beforeEach(() => {
+    setupDeps = {
+      http: httpServiceMock.createSetupContract(),
+      rendering: renderingMock.createSetupContract(),
+    };
+    service = new HttpResourcesService(coreContext);
+    router = httpServiceMock.createRouter();
+  });
+  describe('#createRegistrar', () => {
+    describe('registerCoreApp', () => {
+      it('registers core app with route config', async () => {
+        const routeConfig: RouteConfig<any, any, any, 'get'> = { path: '/', validate: false };
+        const { createRegistrar } = await service.setup(setupDeps);
+        const { registerCoreApp } = createRegistrar(router);
+        registerCoreApp(routeConfig);
+
+        const [[routerConfig]] = router.get.mock.calls;
+        expect(routerConfig).toBe(routeConfig);
+      });
+
+      it('renders page with user settings and CSP header', async () => {
+        const routeConfig: RouteConfig<any, any, any, 'get'> = { path: '/', validate: false };
+        const { createRegistrar } = await service.setup(setupDeps);
+        const { registerCoreApp } = createRegistrar(router);
+        registerCoreApp(routeConfig);
+
+        const [[, routeHandler]] = router.get.mock.calls;
+
+        const responseFactory = httpResourcesMock.createResponseFactory();
+        await routeHandler(context, kibanaRequest, responseFactory);
+
+        expect(setupDeps.rendering.render).toHaveBeenCalledWith(
+          kibanaRequest,
+          context.core.uiSettings.client,
+          {
+            includeUserSettings: true,
+          }
+        );
+
+        expect(responseFactory.ok).toHaveBeenCalledWith({
+          body: '<body />',
+          headers: {
+            'content-security-policy':
+              "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'",
+          },
+        });
+      });
+
+      it('can attach headers, except the CSP header', async () => {
+        const routeConfig: RouteConfig<any, any, any, 'get'> = { path: '/', validate: false };
+        const { createRegistrar } = await service.setup(setupDeps);
+        const { registerCoreApp } = createRegistrar(router);
+        registerCoreApp(routeConfig, {
+          headers: {
+            'content-security-policy': "script-src 'unsafe-eval'",
+            'x-kibana': '42',
+          },
+        });
+
+        const [[, routeHandler]] = router.get.mock.calls;
+
+        const responseFactory = httpResourcesMock.createResponseFactory();
+        await routeHandler(context, kibanaRequest, responseFactory);
+
+        expect(responseFactory.ok).toHaveBeenCalledWith({
+          body: '<body />',
+          headers: {
+            'x-kibana': '42',
+            'content-security-policy':
+              "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'",
+          },
+        });
+      });
+    });
+    describe('registerAnonymousCoreApp', () => {
+      it('registers core app with route config', async () => {
+        const routeConfig: RouteConfig<any, any, any, 'get'> = { path: '/', validate: false };
+        const { createRegistrar } = await service.setup(setupDeps);
+        const { registerAnonymousCoreApp } = createRegistrar(router);
+        registerAnonymousCoreApp(routeConfig);
+
+        const [[routerConfig]] = router.get.mock.calls;
+        expect(routerConfig).toBe(routeConfig);
+      });
+
+      it('renders page with user settings and CSP header', async () => {
+        const routeConfig: RouteConfig<any, any, any, 'get'> = { path: '/', validate: false };
+        const { createRegistrar } = await service.setup(setupDeps);
+        const { registerAnonymousCoreApp } = createRegistrar(router);
+        registerAnonymousCoreApp(routeConfig);
+
+        const [[, routeHandler]] = router.get.mock.calls;
+
+        const responseFactory = httpResourcesMock.createResponseFactory();
+        await routeHandler(context, kibanaRequest, responseFactory);
+
+        expect(setupDeps.rendering.render).toHaveBeenCalledWith(
+          kibanaRequest,
+          context.core.uiSettings.client,
+          {
+            includeUserSettings: false,
+          }
+        );
+
+        expect(responseFactory.ok).toHaveBeenCalledWith({
+          body: '<body />',
+          headers: {
+            'content-security-policy':
+              "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'",
+          },
+        });
+      });
+
+      it('can attach headers, except the CSP header', async () => {
+        const routeConfig: RouteConfig<any, any, any, 'get'> = { path: '/', validate: false };
+        const { createRegistrar } = await service.setup(setupDeps);
+        const { registerAnonymousCoreApp } = createRegistrar(router);
+        registerAnonymousCoreApp(routeConfig, {
+          headers: {
+            'content-security-policy': "script-src 'unsafe-eval'",
+            'x-kibana': '42',
+          },
+        });
+
+        const [[, routeHandler]] = router.get.mock.calls;
+
+        const responseFactory = httpResourcesMock.createResponseFactory();
+        await routeHandler(context, kibanaRequest, responseFactory);
+
+        expect(responseFactory.ok).toHaveBeenCalledWith({
+          body: '<body />',
+          headers: {
+            'x-kibana': '42',
+            'content-security-policy':
+              "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'",
+          },
+        });
+      });
+    });
+    it.todo('register');
+  });
+});