[RAM] Rule type params OAS verification and POC

.github/CODEOWNERS

@@ -443,6 +443,7 @@ x-pack/examples/gen_ai_streaming_response_example @elastic/response-ops
 packages/kbn-generate @elastic/kibana-operations
 packages/kbn-generate-console-definitions @elastic/platform-deployment-management
 packages/kbn-generate-csv @elastic/appex-sharedux
+packages/kbn-generate-oas @elastic/kibana-core
 packages/kbn-get-repo-files @elastic/kibana-operations
 x-pack/plugins/global_search_bar @elastic/appex-sharedux
 x-pack/plugins/global_search @elastic/appex-sharedux
@@ -889,6 +890,7 @@ packages/kbn-web-worker-stub @elastic/kibana-operations
 packages/kbn-whereis-pkg-cli @elastic/kibana-operations
 packages/kbn-xstate-utils @elastic/obs-ux-logs-team
 packages/kbn-yarn-lock-validator @elastic/kibana-operations
+packages/kbn-zod @elastic/kibana-core
 packages/kbn-zod-helpers @elastic/security-detection-rule-management
 ####
 ## Everything below this line overrides the default assignments for each package.

package.json

@@ -476,6 +476,7 @@
     "@kbn/gen-ai-streaming-response-example-plugin": "link:x-pack/examples/gen_ai_streaming_response_example",
     "@kbn/generate-console-definitions": "link:packages/kbn-generate-console-definitions",
     "@kbn/generate-csv": "link:packages/kbn-generate-csv",
+    "@kbn/generate-oas": "link:packages/kbn-generate-oas",
     "@kbn/global-search-bar-plugin": "link:x-pack/plugins/global_search_bar",
     "@kbn/global-search-plugin": "link:x-pack/plugins/global_search",
     "@kbn/global-search-providers-plugin": "link:x-pack/plugins/global_search_providers",
@@ -874,6 +875,7 @@
     "@kbn/visualizations-plugin": "link:src/plugins/visualizations",
     "@kbn/watcher-plugin": "link:x-pack/plugins/watcher",
     "@kbn/xstate-utils": "link:packages/kbn-xstate-utils",
+    "@kbn/zod": "link:packages/kbn-zod",
     "@kbn/zod-helpers": "link:packages/kbn-zod-helpers",
     "@loaders.gl/core": "^3.4.7",
     "@loaders.gl/json": "^3.4.7",
@@ -999,6 +1001,7 @@
     "ipaddr.js": "2.0.0",
     "isbinaryfile": "4.0.2",
     "joi": "^17.7.1",
+    "joi-to-json": "^4.2.0",
     "jquery": "^3.5.0",
     "js-levenshtein": "^1.1.6",
     "js-search": "^1.4.3",
@@ -1147,7 +1150,8 @@
     "xterm": "^5.1.0",
     "yauzl": "^2.10.0",
     "yazl": "^2.5.1",
-    "zod": "^3.22.3"
+    "zod": "^3.22.3",
+    "zod-to-json-schema": "^3.22.3"
   },
   "devDependencies": {
     "@apidevtools/swagger-parser": "^10.0.3",

packages/core/http/core-http-router-server-internal/index.ts

@@ -7,6 +7,8 @@
  */
 
 export { filterHeaders } from './src/headers';
+export { versionHandlerResolvers } from './src/versioned_router';
+export { CoreVersionedRouter } from './src/versioned_router';
 export { Router, type RouterOptions } from './src/router';
 export type { HandlerResolutionStrategy } from './src/versioned_router';
 export { isKibanaRequest, isRealRequest, ensureRawRequest, CoreKibanaRequest } from './src/request';

packages/core/http/core-http-router-server-internal/src/router.ts

@@ -24,6 +24,7 @@ import type {
   IRouter,
   RequestHandler,
   VersionedRouter,
+  RouteRegistrar,
 } from '@kbn/core-http-server';
 import { validBodyOutput } from '@kbn/core-http-server';
 import { RouteValidator } from './validator';
@@ -32,6 +33,7 @@ import { CoreKibanaRequest } from './request';
 import { kibanaResponseFactory } from './response';
 import { HapiResponseAdapter } from './response_adapter';
 import { wrapErrors } from './error_wrapper';
+import { Method } from './versioned_router/types';
 
 export type ContextEnhancer<
   P,
@@ -133,18 +135,35 @@ export interface RouterOptions {
   };
 }
 
+/** @internal */
+interface InternalRegistrarOptions {
+  isVersioned: boolean;
+}
+
+/** @internal */
+type InternalRegistrar<M extends Method, C extends RequestHandlerContextBase> = <P, Q, B>(
+  route: RouteConfig<P, Q, B, M>,
+  handler: RequestHandler<P, Q, B, C, M>,
+  internalOpts?: InternalRegistrarOptions
+) => ReturnType<RouteRegistrar<M, C>>;
+
+/** @internal */
+interface InternalRouterRoute extends RouterRoute {
+  readonly isVersioned: boolean;
+}
+
 /**
  * @internal
  */
 export class Router<Context extends RequestHandlerContextBase = RequestHandlerContextBase>
   implements IRouter<Context>
 {
-  public routes: Array<Readonly<RouterRoute>> = [];
-  public get: IRouter<Context>['get'];
-  public post: IRouter<Context>['post'];
-  public delete: IRouter<Context>['delete'];
-  public put: IRouter<Context>['put'];
-  public patch: IRouter<Context>['patch'];
+  public routes: Array<Readonly<InternalRouterRoute>> = [];
+  public get: InternalRegistrar<'get', Context>;
+  public post: InternalRegistrar<'post', Context>;
+  public delete: InternalRegistrar<'delete', Context>;
+  public put: InternalRegistrar<'put', Context>;
+  public patch: InternalRegistrar<'patch', Context>;
 
   constructor(
     public readonly routerPath: string,
@@ -156,7 +175,8 @@ export class Router<Context extends RequestHandlerContextBase = RequestHandlerCo
       <Method extends RouteMethod>(method: Method) =>
       <P, Q, B>(
         route: RouteConfig<P, Q, B, Method>,
-        handler: RequestHandler<P, Q, B, Context, Method>
+        handler: RequestHandler<P, Q, B, Context, Method>,
+        internalOptions: { isVersioned: boolean } = { isVersioned: false }
       ) => {
         const routeSchemas = routeSchemasFromRouteConfig(route, method);
 
@@ -171,6 +191,8 @@ export class Router<Context extends RequestHandlerContextBase = RequestHandlerCo
           method,
           path: getRouteFullPath(this.routerPath, route.path),
           options: validOptions(method, route),
+          validationSchemas: route.validate, // Added here for introspection
+          isVersioned: internalOptions.isVersioned,
         });
       };
 
@@ -181,7 +203,10 @@ export class Router<Context extends RequestHandlerContextBase = RequestHandlerCo
     this.patch = buildMethod('patch');
   }
 
-  public getRoutes() {
+  public getRoutes(excludeVersionedRoutes = false) {
+    if (excludeVersionedRoutes) {
+      return this.routes.filter((route) => !route.isVersioned);
+    }
     return [...this.routes];
   }
 

packages/core/http/core-http-router-server-internal/src/versioned_router/core_versioned_route.ts

@@ -23,7 +23,7 @@ import type {
   RouteConfigOptions,
 } from '@kbn/core-http-server';
 import type { Mutable } from 'utility-types';
-import type { Method } from './types';
+import type { Method, VersionedRouterRoute } from './types';
 import type { CoreVersionedRouter } from './core_versioned_router';
 
 import { validate } from './validate';
@@ -47,6 +47,12 @@ export const passThroughValidation = {
   query: schema.nullable(schema.any()),
 };
 
+function extractValidationSchemaFromHandler(handler: VersionedRouterRoute['handlers'][0]) {
+  if (handler.options.validate === false) return undefined;
+  if (typeof handler.options.validate === 'function') return handler.options.validate();
+  return handler.options.validate;
+}
+
 export class CoreVersionedRoute implements VersionedRoute {
   private readonly handlers = new Map<
     ApiVersion,
@@ -88,7 +94,8 @@ export class CoreVersionedRoute implements VersionedRoute {
         validate: passThroughValidation,
         options: this.getRouteConfigOptions(),
       },
-      this.requestHandler
+      this.requestHandler,
+      { isVersioned: true }
     );
   }
 
@@ -156,7 +163,7 @@ export class CoreVersionedRoute implements VersionedRoute {
         }]. Available versions are: ${this.versionsToString()}`,
       });
     }
-    const validation = handler.options.validate || undefined;
+    const validation = extractValidationSchemaFromHandler(handler);
     if (
       validation?.request &&
       Boolean(validation.request.body || validation.request.params || validation.request.query)

packages/core/http/core-http-router-server-internal/src/versioned_router/core_versioned_router.ts

@@ -6,14 +6,14 @@
  * Side Public License, v 1.
  */
 
-import type { IRouter } from '@kbn/core-http-server';
 import type { VersionedRouter, VersionedRoute, VersionedRouteConfig } from '@kbn/core-http-server';
+import type { Router } from '../router';
 import { CoreVersionedRoute } from './core_versioned_route';
 import type { HandlerResolutionStrategy, Method, VersionedRouterRoute } from './types';
 
 /** @internal */
 export interface VersionedRouterArgs {
-  router: IRouter;
+  router: Router;
   /**
    * Which route resolution algo to use.
    * @note default to "oldest", but when running in dev default to "none"
@@ -56,7 +56,7 @@ export class CoreVersionedRouter implements VersionedRouter {
     );
   }
   private constructor(
-    public readonly router: IRouter,
+    public readonly router: Router,
     public readonly defaultHandlerResolutionStrategy: HandlerResolutionStrategy = 'oldest',
     public readonly isDev: boolean = false,
     useVersionResolutionStrategyForInternalPaths: string[] = []

packages/core/http/core-http-router-server-internal/src/versioned_router/index.ts

@@ -5,6 +5,6 @@
  * in compliance with, at your election, the Elastic License 2.0 or the Server
  * Side Public License, v 1.
  */
-
+export { resolvers as versionHandlerResolvers } from './handler_resolvers';
 export { CoreVersionedRouter } from './core_versioned_router';
 export type { HandlerResolutionStrategy } from './types';

packages/core/http/core-http-router-server-internal/src/versioned_router/validate.ts

@@ -6,17 +6,50 @@
  * Side Public License, v 1.
  */
 
-import type { RouteValidatorFullConfig } from '@kbn/core-http-server';
+import {
+  type VersionedRouteRequestValidation,
+  type VersionedSpecValidation,
+  type RouteValidationFunction,
+  RouteValidationError,
+} from '@kbn/core-http-server';
+import { z, extractErrorMessage } from '@kbn/zod';
 import type { ApiVersion } from '@kbn/core-http-server';
+import { instanceofZodType } from '@kbn/zod';
+import type { Type } from '@kbn/config-schema';
 import { RouteValidator } from '../validator';
 
+function makeValidationFunction(schema: z.ZodTypeAny): RouteValidationFunction<unknown> {
+  return (data: unknown) => {
+    const result = schema.safeParse(data);
+    if (!result.success) {
+      return {
+        error: new RouteValidationError(extractErrorMessage(result.error)),
+        value: undefined,
+      };
+    }
+    return { error: undefined, value: result.data };
+  };
+}
+
+function getValidator(
+  handler?: VersionedSpecValidation
+): RouteValidationFunction<unknown> | Type<unknown> | undefined {
+  return instanceofZodType(handler)
+    ? makeValidationFunction(handler)
+    : (handler as RouteValidationFunction<unknown> | Type<unknown> | undefined);
+}
+
 /** Will throw if any of the validation checks fail */
 export function validate(
   data: { body?: unknown; params?: unknown; query?: unknown },
-  runtimeSchema: RouteValidatorFullConfig<unknown, unknown, unknown>,
+  runtimeSchema: VersionedRouteRequestValidation<unknown, unknown, unknown>,
   version: ApiVersion
 ): { body: unknown; params: unknown; query: unknown } {
-  const validator = RouteValidator.from(runtimeSchema);
+  const validator = RouteValidator.from({
+    body: getValidator(runtimeSchema.body),
+    params: getValidator(runtimeSchema.params),
+    query: getValidator(runtimeSchema.query),
+  });
   return {
     params: validator.getParams(data.params, 'request params'),
     query: validator.getQuery(data.query, 'request query'),

packages/core/http/core-http-router-server-internal/tsconfig.json

@@ -7,7 +7,7 @@
       "node"
     ]
   },
-  "include": [ "**/*.ts" ],
+  "include": [ "**/*.ts", "src/versioned_router/oas_poc/run.js", "src/versioned_router/oas_poc/generate.js" ],
   "kbn_references": [
     "@kbn/std",
     "@kbn/utility-types",
@@ -17,7 +17,8 @@
     "@kbn/hapi-mocks",
     "@kbn/core-logging-server-mocks",
     "@kbn/logging",
-    "@kbn/core-http-common"
+    "@kbn/core-http-common",
+    "@kbn/zod"
   ],
   "exclude": [
     "target/**/*",

packages/core/http/core-http-server-internal/src/http_server.ts

@@ -8,6 +8,7 @@
 
 import { Server, Request } from '@hapi/hapi';
 import HapiStaticFiles from '@hapi/inert';
+import { generateOpenApiDocument } from '@kbn/generate-oas';
 import url from 'url';
 import { v4 as uuidv4 } from 'uuid';
 import {
@@ -26,7 +27,7 @@ import apm from 'elastic-apm-node';
 import Brok from 'brok';
 import type { Logger, LoggerFactory } from '@kbn/logging';
 import type { InternalExecutionContextSetup } from '@kbn/core-execution-context-server-internal';
-import { isSafeMethod } from '@kbn/core-http-router-server-internal';
+import { CoreVersionedRouter, isSafeMethod, Router } from '@kbn/core-http-router-server-internal';
 import type {
   IRouter,
   RouteConfigOptions,
@@ -204,6 +205,10 @@ export class HttpServer {
     return this.server !== undefined && this.server.listener.listening;
   }
 
+  public getRegisteredRouters() {
+    return [...this.registeredRouters];
+  }
+
   private registerRouter(router: IRouter) {
     if (this.isListening()) {
       throw new Error('Routers can be registered only when HTTP server is stopped.');
@@ -330,6 +335,8 @@ export class HttpServer {
       }
     }
 
+    this.registerOasEndpoint();
+
     await this.server.start();
     const serverPath =
       this.config && this.config.rewriteBasePath && this.config.basePath !== undefined
@@ -623,6 +630,51 @@ export class HttpServer {
     });
   }
 
+  private oasCache: undefined | object;
+  private registerOasEndpoint() {
+    this.server!.route({
+      path: '/api/oas',
+      method: 'GET',
+      handler: (req, h) => {
+        // TODO cache the result of generating OAS
+        // if (this.oasCache) return h.response(this.oasCache);
+
+        const pathStartsWith = req.query?.pathStartsWith;
+        try {
+          const routers = this.getRegisteredRouters().flatMap((r) => {
+            const rs: Array<Router | CoreVersionedRouter> = [];
+            if ((r as Router).getRoutes(true).length > 0) {
+              rs.push(r as Router);
+            }
+            const versionedRouter = r.versioned as CoreVersionedRouter;
+            if (versionedRouter.getRoutes().length > 0) {
+              rs.push(versionedRouter);
+            }
+            return rs;
+          });
+          this.oasCache = generateOpenApiDocument(routers, {
+            baseUrl: 'todo',
+            title: 'todo',
+            version: '0.0.0',
+            pathStartsWith,
+          });
+          return h.response(this.oasCache);
+        } catch (e) {
+          this.log.error(e);
+          return h.response({ message: e.message }).code(500);
+        }
+      },
+      options: {
+        app: { access: 'public' },
+        auth: false,
+        cache: {
+          privacy: 'public',
+          otherwise: 'must-revalidate',
+        },
+      },
+    });
+  }
+
   private registerStaticDir(path: string, dirPath: string) {
     if (this.server === undefined) {
       throw new Error('Http server is not setup up yet');