Route tags

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

@@ -690,6 +690,7 @@ test('#setBasePathFor() cannot be set twice for one request', async () => {
           raw: {
             req: incomingMessage,
           },
+          route: { settings: {} },
         } as any,
         undefined
       );
@@ -739,7 +740,9 @@ test('Should support disabling auth for a route', async () => {
   const { registerAuth, registerRouter, server: innerServer } = await server.setup(config);
 
   const router = new Router('');
-  router.get({ path: '/', validate: false, authRequired: false }, async (req, res) => res.ok({}));
+  router.get({ path: '/', validate: false, options: { authRequired: false } }, async (req, res) =>
+    res.ok({})
+  );
   registerRouter(router);
   const authenticate = jest.fn();
   await registerAuth(authenticate, cookieOptions);
@@ -774,7 +777,7 @@ describe('#auth.isAuthenticated()', () => {
     const { registerAuth, registerRouter, server: innerServer, auth } = await server.setup(config);
 
     const router = new Router('');
-    router.get({ path: '/', validate: false, authRequired: false }, async (req, res) =>
+    router.get({ path: '/', validate: false, options: { authRequired: false } }, async (req, res) =>
       res.ok({ isAuthenticated: auth.isAuthenticated(req) })
     );
     registerRouter(router);
@@ -791,7 +794,7 @@ describe('#auth.isAuthenticated()', () => {
     const { registerRouter, server: innerServer, auth } = await server.setup(config);
 
     const router = new Router('');
-    router.get({ path: '/', validate: false, authRequired: false }, async (req, res) =>
+    router.get({ path: '/', validate: false, options: { authRequired: false } }, async (req, res) =>
       res.ok({ isAuthenticated: auth.isAuthenticated(req) })
     );
     registerRouter(router);
@@ -840,7 +843,7 @@ describe('#auth.get()', () => {
     const { registerRouter, registerAuth, server: innerServer, auth } = await server.setup(config);
     await registerAuth(authenticate, cookieOptions);
     const router = new Router('');
-    router.get({ path: '/', validate: false, authRequired: false }, async (req, res) =>
+    router.get({ path: '/', validate: false, options: { authRequired: false } }, async (req, res) =>
       res.ok(auth.get(req))
     );
 

src/core/server/http/http_server.ts

@@ -157,13 +157,14 @@ export class HttpServer {
 
     for (const router of this.registeredRouters) {
       for (const route of router.getRoutes()) {
-        const isAuthRequired = Boolean(this.authRegistered && route.authRequired);
+        const { authRequired = true, tags } = route.options;
         this.server.route({
           handler: route.handler,
           method: route.method,
           path: this.getRouteFullPath(router.path, route.path),
           options: {
-            auth: isAuthRequired ? undefined : false,
+            auth: this.authRegistered && authRequired ? undefined : false,
+            tags,
           },
         });
       }

src/core/server/http/lifecycle/auth.test.ts

@@ -23,7 +23,7 @@ import { adoptToHapiAuthFormat } from './auth';
 const SessionStorageMock = {
   asScoped: () => null as any,
 };
-const requestMock = {} as any;
+const requestMock = { route: { settings: {} } } as any;
 const createResponseToolkit = (customization = {}): any => ({ ...customization });
 
 describe('adoptToHapiAuthFormat', () => {

src/core/server/http/lifecycle/on_post_auth.test.ts

@@ -20,7 +20,7 @@
 import Boom from 'boom';
 import { adoptToHapiOnPostAuthFormat } from './on_post_auth';
 
-const requestMock = {} as any;
+const requestMock = { route: { settings: {} } } as any;
 const createResponseToolkit = (customization = {}): any => ({ ...customization });
 
 describe('adoptToHapiOnPostAuthFormat', () => {

src/core/server/http/lifecycle/on_pre_auth.test.ts

@@ -20,15 +20,20 @@
 import Boom from 'boom';
 import { adoptToHapiOnPreAuthFormat } from './on_pre_auth';
 
-const requestMock = {} as any;
+const createRequestMock = (customization: object = {}) =>
+  ({
+    route: { settings: {} },
+    raw: { req: {} },
+    ...customization,
+  } as any);
 const createResponseToolkit = (customization = {}): any => ({ ...customization });
 
 describe('adoptToHapiOnPreAuthFormat', () => {
   it('Should allow passing request to the next handler', async () => {
     const continueSymbol = {};
     const onPreAuth = adoptToHapiOnPreAuthFormat((req, t) => t.next());
     const result = await onPreAuth(
-      requestMock,
+      createRequestMock(),
       createResponseToolkit({
         ['continue']: continueSymbol,
       })
@@ -43,7 +48,7 @@ describe('adoptToHapiOnPreAuthFormat', () => {
     const takeoverSymbol = {};
     const redirectMock = jest.fn(() => ({ takeover: () => takeoverSymbol }));
     const result = await onPreAuth(
-      requestMock,
+      createRequestMock(),
       createResponseToolkit({
         redirect: redirectMock,
       })
@@ -60,24 +65,24 @@ describe('adoptToHapiOnPreAuthFormat', () => {
     );
     const continueSymbol = {};
     const setUrl = jest.fn();
-    const reqMock = { setUrl, raw: { req: {} } } as any;
+    const requestMock = createRequestMock({ setUrl });
     const result = await onPreAuth(
-      reqMock as any,
+      requestMock,
       createResponseToolkit({
         ['continue']: continueSymbol,
       })
     );
 
     expect(setUrl).toBeCalledWith(redirectUrl);
-    expect(reqMock.raw.req.url).toBe(redirectUrl);
+    expect(requestMock.raw.req.url).toBe(redirectUrl);
     expect(result).toBe(continueSymbol);
   });
 
   it('Should support specifying statusCode and message for Boom error', async () => {
     const onPreAuth = adoptToHapiOnPreAuthFormat((req, t) => {
       return t.rejected(new Error('unexpected result'), { statusCode: 501 });
     });
-    const result = (await onPreAuth(requestMock, createResponseToolkit())) as Boom;
+    const result = (await onPreAuth(createRequestMock(), createResponseToolkit())) as Boom;
 
     expect(result).toBeInstanceOf(Boom);
     expect(result.message).toBe('unexpected result');
@@ -88,7 +93,7 @@ describe('adoptToHapiOnPreAuthFormat', () => {
     const onPreAuth = adoptToHapiOnPreAuthFormat((req, t) => {
       throw new Error('unknown error');
     });
-    const result = (await onPreAuth(requestMock, createResponseToolkit())) as Boom;
+    const result = (await onPreAuth(createRequestMock(), createResponseToolkit())) as Boom;
 
     expect(result).toBeInstanceOf(Boom);
     expect(result.message).toBe('unknown error');
@@ -97,7 +102,7 @@ describe('adoptToHapiOnPreAuthFormat', () => {
 
   it('Should return Boom.internal error if interceptor returns unexpected result', async () => {
     const onPreAuth = adoptToHapiOnPreAuthFormat((req, toolkit) => undefined as any);
-    const result = (await onPreAuth(requestMock, createResponseToolkit())) as Boom;
+    const result = (await onPreAuth(createRequestMock(), createResponseToolkit())) as Boom;
 
     expect(result).toBeInstanceOf(Boom);
     expect(result.message).toMatchInlineSnapshot(

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

@@ -22,10 +22,26 @@ import { ObjectType, TypeOf } from '@kbn/config-schema';
 import { Request } from 'hapi';
 
 import { filterHeaders, Headers } from './headers';
-import { RouteSchemas } from './route';
+import { RouteSchemas, RouteConfigOptions } from './route';
+
+interface KibanaRequestRoute {
+  path: string;
+  method: 'get' | 'post' | 'put' | 'patch' | 'delete' | 'options';
+  options: RouteConfigOptions;
+}
 
 /** @public */
 export class KibanaRequest<Params = unknown, Query = unknown, Body = unknown> {
+  public static getRoute(request: Request): KibanaRequestRoute {
+    return {
+      path: request.path,
+      method: request.method,
+      options: {
+        authRequired: request.route.settings.auth === false ? false : true,
+        tags: request.route.settings.tags || [],
+      },
+    };
+  }
   /**
    * Factory for creating requests. Validates the request before creating an
    * instance of a KibanaRequest.
@@ -35,7 +51,14 @@ export class KibanaRequest<Params = unknown, Query = unknown, Body = unknown> {
     routeSchemas: RouteSchemas<P, Q, B> | undefined
   ) {
     const requestParts = KibanaRequest.validate(req, routeSchemas);
-    return new KibanaRequest(req, requestParts.params, requestParts.query, requestParts.body);
+    const route = KibanaRequest.getRoute(req);
+    return new KibanaRequest(
+      req,
+      requestParts.params,
+      requestParts.query,
+      requestParts.body,
+      route
+    );
   }
 
   /**
@@ -70,17 +93,16 @@ export class KibanaRequest<Params = unknown, Query = unknown, Body = unknown> {
   }
 
   public readonly headers: Headers;
-  public readonly path: string;
   public readonly url: Url;
 
   constructor(
     private readonly request: Request,
     readonly params: Params,
     readonly query: Query,
-    readonly body: Body
+    readonly body: Body,
+    readonly route: KibanaRequestRoute
   ) {
     this.headers = request.headers;
-    this.path = request.path;
     this.url = request.url;
   }
 

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

@@ -18,7 +18,23 @@
  */
 
 import { ObjectType, Schema } from '@kbn/config-schema';
-export type RouteMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
+export type RouteMethod = 'get' | 'post' | 'put' | 'delete';
+
+export interface RouteConfigOptions {
+  /**
+   * A flag shows that authentication for a route:
+   * enabled  when true
+   * disabled when false
+   *
+   * Enabled by default.
+   */
+  authRequired?: boolean;
+
+  /**
+   * Additional meta-data information to attach fot the route.
+   */
+  tags?: string[];
+}
 
 export interface RouteConfig<P extends ObjectType, Q extends ObjectType, B extends ObjectType> {
   /**
@@ -36,14 +52,7 @@ export interface RouteConfig<P extends ObjectType, Q extends ObjectType, B exten
    */
   validate: RouteValidateFactory<P, Q, B> | false;
 
-  /**
-   * A flag shows that authentication for a route:
-   * enabled  when true
-   * disabled when false
-   *
-   * Enabled by default.
-   */
-  authRequired?: boolean;
+  options?: RouteConfigOptions;
 }
 
 export type RouteValidateFactory<

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

@@ -22,12 +22,12 @@ import { Request, ResponseObject, ResponseToolkit } from 'hapi';
 
 import { KibanaRequest } from './request';
 import { KibanaResponse, ResponseFactory, responseFactory } from './response';
-import { RouteConfig, RouteMethod, RouteSchemas } from './route';
+import { RouteConfig, RouteConfigOptions, RouteMethod, RouteSchemas } from './route';
 
 export interface RouterRoute {
-  method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+  method: RouteMethod;
   path: string;
-  authRequired: boolean;
+  options: RouteConfigOptions;
   handler: (req: Request, responseToolkit: ResponseToolkit) => Promise<ResponseObject>;
 }
 
@@ -44,14 +44,14 @@ export class Router {
     route: RouteConfig<P, Q, B>,
     handler: RequestHandler<P, Q, B>
   ) {
-    const { path, authRequired = true } = route;
-    const routeSchemas = this.routeSchemasFromRouteConfig(route, 'GET');
+    const { path, options = {} } = route;
+    const routeSchemas = this.routeSchemasFromRouteConfig(route, 'get');
     this.routes.push({
       handler: async (req, responseToolkit) =>
         await this.handle(routeSchemas, req, responseToolkit, handler),
-      method: 'GET',
+      method: 'get',
       path,
-      authRequired,
+      options,
     });
   }
 
@@ -62,14 +62,14 @@ export class Router {
     route: RouteConfig<P, Q, B>,
     handler: RequestHandler<P, Q, B>
   ) {
-    const { path, authRequired = true } = route;
-    const routeSchemas = this.routeSchemasFromRouteConfig(route, 'POST');
+    const { path, options = {} } = route;
+    const routeSchemas = this.routeSchemasFromRouteConfig(route, 'post');
     this.routes.push({
       handler: async (req, responseToolkit) =>
         await this.handle(routeSchemas, req, responseToolkit, handler),
-      method: 'POST',
+      method: 'post',
       path,
-      authRequired,
+      options,
     });
   }
 
@@ -80,14 +80,14 @@ export class Router {
     route: RouteConfig<P, Q, B>,
     handler: RequestHandler<P, Q, B>
   ) {
-    const { path, authRequired = true } = route;
-    const routeSchemas = this.routeSchemasFromRouteConfig(route, 'POST');
+    const { path, options = {} } = route;
+    const routeSchemas = this.routeSchemasFromRouteConfig(route, 'put');
     this.routes.push({
       handler: async (req, responseToolkit) =>
         await this.handle(routeSchemas, req, responseToolkit, handler),
-      method: 'PUT',
+      method: 'put',
       path,
-      authRequired,
+      options,
     });
   }
 
@@ -98,14 +98,14 @@ export class Router {
     route: RouteConfig<P, Q, B>,
     handler: RequestHandler<P, Q, B>
   ) {
-    const { path, authRequired = true } = route;
-    const routeSchemas = this.routeSchemasFromRouteConfig(route, 'DELETE');
+    const { path, options = {} } = route;
+    const routeSchemas = this.routeSchemasFromRouteConfig(route, 'delete');
     this.routes.push({
       handler: async (req, responseToolkit) =>
         await this.handle(routeSchemas, req, responseToolkit, handler),
-      method: 'DELETE',
+      method: 'delete',
       path,
-      authRequired,
+      options,
     });
   }