[data views] Use versioned router for REST routes

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

@@ -136,6 +136,7 @@ export type {
   VersionedRouteRequestValidation,
   VersionedRouteResponseValidation,
   ApiVersion,
+  FullValidationConfig,
   VersionedRoute,
   VersionedRouteConfig,
   VersionedRouteRegistrar,

packages/core/http/core-http-server/src/versioning/index.ts

@@ -9,6 +9,7 @@
 export type {
   ApiVersion,
   AddVersionOpts,
+  FullValidationConfig,
   VersionedRouteRequestValidation,
   VersionedRouteResponseValidation,
   VersionedRoute,

packages/core/http/core-http-server/src/versioning/types.ts

@@ -180,7 +180,7 @@ export interface VersionedRouteResponseValidation {
  * Versioned route validation
  * @experimental
  */
-interface FullValidationConfig<P, Q, B> {
+export interface FullValidationConfig<P, Q, B> {
   /**
    * Validation to run against route inputs: params, query and body
    * @experimental

src/plugins/data_views/common/schemas.ts

@@ -14,52 +14,6 @@ export const serializedFieldFormatSchema = schema.object({
   params: schema.maybe(schema.any()),
 });
 
-export const fieldSpecSchemaFields = {
-  name: schema.string({
-    maxLength: 1000,
-  }),
-  type: schema.string({
-    defaultValue: 'string',
-    maxLength: 1000,
-  }),
-  count: schema.maybe(
-    schema.number({
-      min: 0,
-    })
-  ),
-  script: schema.maybe(
-    schema.string({
-      maxLength: 1000000,
-    })
-  ),
-  format: schema.maybe(serializedFieldFormatSchema),
-  esTypes: schema.maybe(schema.arrayOf(schema.string())),
-  scripted: schema.maybe(schema.boolean()),
-  subType: schema.maybe(
-    schema.object({
-      multi: schema.maybe(
-        schema.object({
-          parent: schema.string(),
-        })
-      ),
-      nested: schema.maybe(
-        schema.object({
-          path: schema.string(),
-        })
-      ),
-    })
-  ),
-  customLabel: schema.maybe(schema.string()),
-  shortDotsEnable: schema.maybe(schema.boolean()),
-};
-
-export const fieldSpecSchema = schema.object(fieldSpecSchemaFields, {
-  // Allow and ignore unknowns to make fields transient.
-  // Because `fields` have a bunch of calculated fields
-  // this allows to retrieve an index pattern and then to re-create by using the retrieved payload
-  unknowns: 'ignore',
-});
-
 export const RUNTIME_FIELD_TYPES2 = [
   'keyword',
   'long',
@@ -76,8 +30,7 @@ export const runtimeFieldNonCompositeFieldsSpecTypeSchema = schema.oneOf(
   ]
 );
 
-export const primitiveRuntimeFieldSchema = schema.object({
-  type: runtimeFieldNonCompositeFieldsSpecTypeSchema,
+const primitiveRuntimeFieldSchemaShared = {
   script: schema.maybe(
     schema.object({
       source: schema.string(),
@@ -90,10 +43,19 @@ export const primitiveRuntimeFieldSchema = schema.object({
       min: 0,
     })
   ),
+};
+
+export const primitiveRuntimeFieldSchema = schema.object({
+  type: runtimeFieldNonCompositeFieldsSpecTypeSchema,
+  ...primitiveRuntimeFieldSchemaShared,
 });
 
-export const compositeRuntimeFieldSchema = schema.object({
-  type: schema.literal('composite') as Type<RuntimeType>,
+const primitiveRuntimeFieldSchemaUpdate = schema.object({
+  type: schema.maybe(runtimeFieldNonCompositeFieldsSpecTypeSchema),
+  ...primitiveRuntimeFieldSchemaShared,
+});
+
+const compositeRuntimeFieldSchemaShared = {
   script: schema.maybe(
     schema.object({
       source: schema.string(),
@@ -114,9 +76,74 @@ export const compositeRuntimeFieldSchema = schema.object({
       })
     )
   ),
+};
+
+export const compositeRuntimeFieldSchema = schema.object({
+  type: schema.literal('composite') as Type<RuntimeType>,
+  ...compositeRuntimeFieldSchemaShared,
+});
+
+const compositeRuntimeFieldSchemaUpdate = schema.object({
+  type: schema.maybe(schema.literal('composite') as Type<RuntimeType>),
+  ...compositeRuntimeFieldSchemaShared,
 });
 
 export const runtimeFieldSchema = schema.oneOf([
   primitiveRuntimeFieldSchema,
   compositeRuntimeFieldSchema,
 ]);
+
+export const runtimeFieldSchemaUpdate = schema.oneOf([
+  primitiveRuntimeFieldSchemaUpdate,
+  compositeRuntimeFieldSchemaUpdate,
+]);
+
+export const fieldSpecSchemaFields = {
+  name: schema.string({
+    maxLength: 1000,
+  }),
+  type: schema.string({
+    defaultValue: 'string',
+    maxLength: 1000,
+  }),
+  count: schema.maybe(
+    schema.number({
+      min: 0,
+    })
+  ),
+  script: schema.maybe(
+    schema.string({
+      maxLength: 1000000,
+    })
+  ),
+  format: schema.maybe(serializedFieldFormatSchema),
+  esTypes: schema.maybe(schema.arrayOf(schema.string())),
+  scripted: schema.maybe(schema.boolean()),
+  subType: schema.maybe(
+    schema.object({
+      multi: schema.maybe(
+        schema.object({
+          parent: schema.string(),
+        })
+      ),
+      nested: schema.maybe(
+        schema.object({
+          path: schema.string(),
+        })
+      ),
+    })
+  ),
+  customLabel: schema.maybe(schema.string()),
+  shortDotsEnable: schema.maybe(schema.boolean()),
+  searchable: schema.maybe(schema.boolean()),
+  aggregatable: schema.maybe(schema.boolean()),
+  readFromDocValues: schema.maybe(schema.boolean()),
+  runtimeField: schema.maybe(runtimeFieldSchema),
+};
+
+export const fieldSpecSchema = schema.object(fieldSpecSchemaFields, {
+  // Allow and ignore unknowns to make fields transient.
+  // Because `fields` have a bunch of calculated fields
+  // this allows to retrieve an index pattern and then to re-create by using the retrieved payload
+  unknowns: 'ignore',
+});

src/plugins/data_views/public/data_views/data_views_api_client.ts

@@ -12,6 +12,7 @@ import { GetFieldsOptions, IDataViewsApiClient } from '../../common';
 import { FieldsForWildcardResponse } from '../../common/types';
 
 const API_BASE_URL: string = `/api/index_patterns/`;
+const version = '1';
 
 /**
  * Data Views API Client - client implementation
@@ -29,8 +30,8 @@ export class DataViewsApiClient implements IDataViewsApiClient {
 
   private _request<T = unknown>(url: string, query?: {}, body?: string): Promise<T | undefined> {
     const request = body
-      ? this.http.post<T>(url, { query, body })
-      : this.http.fetch<T>(url, { query });
+      ? this.http.post<T>(url, { query, body, version })
+      : this.http.fetch<T>(url, { query, version });
     return request.catch((resp) => {
       if (resp.body.statusCode === 404 && resp.body.attributes?.code === 'no_matching_indices') {
         throw new DataViewMissingIndices(resp.body.message);

src/plugins/data_views/public/services/has_data.ts

@@ -157,7 +157,7 @@ export class HasData {
   // Data Views
 
   private getHasDataViews = async ({ http }: { http: HttpStart }): Promise<HasDataViewsResponse> =>
-    http.get<HasDataViewsResponse>(`/internal/data_views/has_data_views`);
+    http.get<HasDataViewsResponse>(`/internal/data_views/has_data_views`, { version: '1' });
 
   private hasDataViews = (http: HttpStart): Promise<boolean> => {
     return this.getHasDataViews({ http })

src/plugins/data_views/server/constants.ts

@@ -76,3 +76,15 @@ export const SERVICE_KEY_LEGACY = 'index_pattern';
  * Service keys as type
  */
 export type SERVICE_KEY_TYPE = typeof SERVICE_KEY | typeof SERVICE_KEY_LEGACY;
+
+/**
+ * Initial REST version date
+ */
+
+export const INITIAL_REST_VERSION = '2023-10-31';
+
+/**
+ * Initial REST version internal
+ */
+
+export const INITIAL_REST_VERSION_INTERNAL = '1';

src/plugins/data_views/server/routes/fields_for.ts → src/plugins/data_views/server/rest_api_routes/internal/fields_for.ts

@@ -8,14 +8,15 @@
 
 import { estypes } from '@elastic/elasticsearch';
 import { schema } from '@kbn/config-schema';
-import {
-  IRouter,
-  RequestHandler,
-  RouteValidatorFullConfig,
-  StartServicesAccessor,
-} from '@kbn/core/server';
-import { IndexPatternsFetcher } from '../fetcher';
-import type { DataViewsServerPluginStart, DataViewsServerPluginStartDependencies } from '../types';
+import { IRouter, RequestHandler, StartServicesAccessor } from '@kbn/core/server';
+import { FullValidationConfig } from '@kbn/core-http-server';
+import { INITIAL_REST_VERSION_INTERNAL as version } from '../../constants';
+import { IndexPatternsFetcher } from '../../fetcher';
+import type {
+  DataViewsServerPluginStart,
+  DataViewsServerPluginStartDependencies,
+} from '../../types';
+import type { FieldDescriptorRestResponse } from '../route_types';
 
 /**
  * Accepts one of the following:
@@ -38,6 +39,7 @@ export const parseFields = (fields: string | string[]): string[] => {
 };
 
 const path = '/api/index_patterns/_fields_for_wildcard';
+const access = 'internal';
 
 type IBody = { index_filter?: estypes.QueryDslQueryContainer } | undefined;
 interface IQuery {
@@ -50,21 +52,61 @@ interface IQuery {
   fields?: string[];
 }
 
-const validate: RouteValidatorFullConfig<{}, IQuery, IBody> = {
-  query: schema.object({
-    pattern: schema.string(),
-    meta_fields: schema.oneOf([schema.string(), schema.arrayOf(schema.string())], {
-      defaultValue: [],
-    }),
-    type: schema.maybe(schema.string()),
-    rollup_index: schema.maybe(schema.string()),
-    allow_no_index: schema.maybe(schema.boolean()),
-    include_unmapped: schema.maybe(schema.boolean()),
-    fields: schema.maybe(schema.oneOf([schema.string(), schema.arrayOf(schema.string())])),
+const querySchema = schema.object({
+  pattern: schema.string(),
+  meta_fields: schema.oneOf([schema.string(), schema.arrayOf(schema.string())], {
+    defaultValue: [],
   }),
-  // not available to get request
-  body: schema.maybe(schema.object({ index_filter: schema.any() })),
+  type: schema.maybe(schema.string()),
+  rollup_index: schema.maybe(schema.string()),
+  allow_no_index: schema.maybe(schema.boolean()),
+  include_unmapped: schema.maybe(schema.boolean()),
+  fields: schema.maybe(schema.oneOf([schema.string(), schema.arrayOf(schema.string())])),
+});
+
+const fieldSubTypeSchema = schema.object({
+  multi: schema.maybe(schema.object({ parent: schema.string() })),
+  nested: schema.maybe(schema.object({ path: schema.string() })),
+});
+
+const FieldDescriptorSchema = schema.object({
+  aggregatable: schema.boolean(),
+  name: schema.string(),
+  readFromDocValues: schema.boolean(),
+  searchable: schema.boolean(),
+  type: schema.string(),
+  esTypes: schema.maybe(schema.arrayOf(schema.string())),
+  subType: fieldSubTypeSchema,
+  metadata_field: schema.maybe(schema.boolean()),
+  fixedInterval: schema.maybe(schema.arrayOf(schema.string())),
+  timeZone: schema.maybe(schema.arrayOf(schema.string())),
+  timeSeriesMetric: schema.maybe(
+    schema.oneOf([
+      schema.literal('histogram'),
+      schema.literal('summary'),
+      schema.literal('counter'),
+      schema.literal('gauge'),
+    ])
+  ),
+  timeSeriesDimension: schema.maybe(schema.boolean()),
+});
+
+const validate: FullValidationConfig<any, any, any> = {
+  request: {
+    query: querySchema,
+    // not available to get request
+    body: schema.maybe(schema.object({ index_filter: schema.any() })),
+  },
+  response: {
+    200: {
+      body: schema.object({
+        fields: schema.arrayOf(FieldDescriptorSchema),
+        indices: schema.arrayOf(schema.string()),
+      }),
+    },
+  },
 };
+
 const handler: RequestHandler<{}, IQuery, IBody> = async (context, request, response) => {
   const { asCurrentUser } = (await context.core).elasticsearch.client;
   const indexPatterns = new IndexPatternsFetcher(asCurrentUser);
@@ -103,8 +145,10 @@ const handler: RequestHandler<{}, IQuery, IBody> = async (context, request, resp
       ...(parsedFields.length > 0 ? { fields: parsedFields } : {}),
     });
 
+    const body: { fields: FieldDescriptorRestResponse[]; indices: string[] } = { fields, indices };
+
     return response.ok({
-      body: { fields, indices },
+      body,
       headers: {
         'content-type': 'application/json',
       },
@@ -136,7 +180,10 @@ export const registerFieldForWildcard = (
     DataViewsServerPluginStart
   >
 ) => {
-  router.put({ path, validate }, handler);
-  router.post({ path, validate }, handler);
-  router.get({ path, validate }, handler);
+  // handler
+  router.versioned.put({ path, access }).addVersion({ version, validate }, handler);
+  router.versioned.post({ path, access }).addVersion({ version, validate }, handler);
+  router.versioned
+    .get({ path, access })
+    .addVersion({ version, validate: { request: { query: querySchema } } }, handler);
 };

src/plugins/data_views/server/routes/has_data_views.test.ts → src/plugins/data_views/server/rest_api_routes/internal/has_data_views.test.ts

@@ -9,7 +9,7 @@
 import type { MockedKeys } from '@kbn/utility-types-jest';
 import { CoreSetup, RequestHandlerContext } from '@kbn/core/server';
 import { coreMock, httpServerMock } from '@kbn/core/server/mocks';
-import { registerHasDataViewsRoute } from './has_data_views';
+import { registerHasDataViewsRoute, handler } from './has_data_views';
 
 describe('preview has_data_views route', () => {
   let mockCoreSetup: MockedKeys<CoreSetup>;
@@ -54,8 +54,6 @@ describe('preview has_data_views route', () => {
 
     registerHasDataViewsRoute(mockCoreSetup.http.createRouter());
 
-    const mockRouter = mockCoreSetup.http.createRouter.mock.results[0].value;
-    const handler = mockRouter.get.mock.calls[0][1];
     await handler(mockContext as unknown as RequestHandlerContext, mockRequest, mockResponse);
 
     expect(mockSOClient.find.mock.calls[0][0]).toMatchInlineSnapshot(`