Merge remote-tracking branch 'upstream/master' into docs/testing

Author: joshdover

STYLEGUIDE.mdx

@@ -35,7 +35,7 @@ remove it, don't simply comment it out.
 
 We are gradually moving the Kibana code base over to Prettier. All TypeScript code
 and some JavaScript code (check `.eslintrc.js`) is using Prettier to format code. You
-can run `node script/eslint --fix` to fix linting issues and apply Prettier formatting.
+can run `node scripts/eslint --fix` to fix linting issues and apply Prettier formatting.
 We recommend you to enable running ESLint via your IDE.
 
 Whenever possible we are trying to use Prettier and linting over written style guide rules.

dev_docs/best_practices.mdx

@@ -171,7 +171,7 @@ Kibana is translated into other languages. Use our i18n utilities to ensure your
 
 ## Styleguide
 
-We use es-lint rules when possible, but please review our [styleguide](https://github.com/elastic/kibana/blob/master/STYLEGUIDE.md), which includes recommendations that can't be linted on.
+We use es-lint rules when possible, but please review our [styleguide](https://github.com/elastic/kibana/blob/master/STYLEGUIDE.mdx), which includes recommendations that can't be linted on.
 
 Es-lint overrides on a per-plugin level are discouraged.
 

docs/developer/best-practices/index.asciidoc

@@ -45,7 +45,7 @@ guidelines]
 === Conventions
 
 * Become familiar with our
-{kib-repo}blob/{branch}/STYLEGUIDE.md[styleguide]
+{kib-repo}blob/{branch}/STYLEGUIDE.mdx[styleguide]
 (use Typescript!)
 * Write all new code on
 {kib-repo}blob/{branch}/src/core/README.md[the

docs/developer/contributing/linting.asciidoc

@@ -2,7 +2,7 @@
 == Linting
 
 A note about linting: We use http://eslint.org[eslint] to check that the
-link:STYLEGUIDE.md[styleguide] is being followed. It runs in a
+link:STYLEGUIDE.mdx[styleguide] is being followed. It runs in a
 pre-commit hook and as a part of the tests, but most contributors
 integrate it with their code editors for real-time feedback.
 

docs/developer/contributing/pr-review.asciidoc

@@ -75,7 +75,7 @@ Reviewers are not simply evaluating the code itself, they are also evaluating th
 
 Having a relatively consistent codebase is an important part of us building a sustainable project. With dozens of active contributors at any given time, we rely on automation to help ensure consistency - we enforce a comprehensive set of linting rules through CI. We're also rolling out prettier to make this even more automatic.
 
-For things that can't be easily automated, we maintain a link:{kib-repo}tree/{branch}/STYLEGUIDE.md[style guide] that authors should adhere to and reviewers should keep in mind when they review a pull request.
+For things that can't be easily automated, we maintain a link:{kib-repo}tree/{branch}/STYLEGUIDE.mdx[style guide] that authors should adhere to and reviewers should keep in mind when they review a pull request.
 
 Beyond that, we're into subjective territory. Statements like "this isn't very readable" are hardly helpful since they can't be qualified, but that doesn't mean a reviewer should outright ignore code that is hard to understand due to how it is written. There isn't one definitively "best" way to write any particular code, so pursuing such shouldn't be our goal. Instead, reviewers and authors alike must accept that there are likely many different appropriate ways to accomplish the same thing with code, and so long as the contribution is utilizing one of those ways, then we're in good shape.
 

examples/routing_example/README.md

@@ -6,4 +6,4 @@ Read more:
 
 - [IRouter API Docs](../../docs/development/core/server/kibana-plugin-core-server.irouter.md)
 - [HttpHandler (core.http.fetch) API Docs](../../docs/development/core/public/kibana-plugin-core-public.httphandler.md)
-- [Routing Conventions](../../STYLEGUIDE.md#api-endpoints)
+- [Routing Conventions](../../STYLEGUIDE.mdx#api-endpoints)

examples/routing_example/public/app.tsx

@@ -63,7 +63,8 @@ function RoutingExplorer({
                 },
                 {
                   label: 'Conventions',
-                  href: 'https://github.com/elastic/kibana/tree/master/STYLEGUIDE.md#api-endpoints',
+                  href:
+                    'https://github.com/elastic/kibana/tree/master/STYLEGUIDE.mdx#api-endpoints',
                   iconType: 'logoGithub',
                   target: '_blank',
                   size: 's',

src/plugins/home/server/services/sample_data/data_sets/ecommerce/saved_objects.ts

@@ -0,0 +1,79 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+import { extendSearchParamsWithRuntimeFields } from './search_api';
+import { dataPluginMock } from '../../../data/public/mocks';
+
+import { getSearchParamsFromRequest, DataPublicPluginStart } from '../../../data/public';
+
+const mockComputedFields = (
+  dataStart: DataPublicPluginStart,
+  index: string,
+  runtimeFields: Record<string, unknown>
+) => {
+  dataStart.indexPatterns.find = jest.fn().mockReturnValue([
+    {
+      title: index,
+      getComputedFields: () => ({
+        runtimeFields,
+      }),
+    },
+  ]);
+};
+
+describe('extendSearchParamsWithRuntimeFields', () => {
+  let dataStart: DataPublicPluginStart;
+
+  beforeEach(() => {
+    dataStart = dataPluginMock.createStartContract();
+  });
+
+  test('should inject default runtime_mappings for known indexes', async () => {
+    const requestParams = {};
+    const runtimeFields = { foo: {} };
+
+    mockComputedFields(dataStart, 'index', runtimeFields);
+
+    expect(
+      await extendSearchParamsWithRuntimeFields(dataStart.indexPatterns, requestParams, 'index')
+    ).toMatchInlineSnapshot(`
+      Object {
+        "body": Object {
+          "runtime_mappings": Object {
+            "foo": Object {},
+          },
+        },
+      }
+    `);
+  });
+
+  test('should use runtime mappings from spec if it is specified', async () => {
+    const requestParams = ({
+      body: {
+        runtime_mappings: {
+          test: {},
+        },
+      },
+    } as unknown) as ReturnType<typeof getSearchParamsFromRequest>;
+    const runtimeFields = { foo: {} };
+
+    mockComputedFields(dataStart, 'index', runtimeFields);
+
+    expect(
+      await extendSearchParamsWithRuntimeFields(dataStart.indexPatterns, requestParams, 'index')
+    ).toMatchInlineSnapshot(`
+      Object {
+        "body": Object {
+          "runtime_mappings": Object {
+            "test": Object {},
+          },
+        },
+      }
+    `);
+  });
+});

src/plugins/vis_type_vega/public/data_model/search_api.test.ts

@@ -8,31 +8,36 @@
 
 import { combineLatest, from } from 'rxjs';
 import { map, tap, switchMap } from 'rxjs/operators';
-import { CoreStart, IUiSettingsClient } from 'kibana/public';
-import { getData } from '../services';
+import type { CoreStart, IUiSettingsClient } from 'kibana/public';
 import {
   getSearchParamsFromRequest,
   SearchRequest,
   DataPublicPluginStart,
   IEsSearchResponse,
 } from '../../../data/public';
 import { search as dataPluginSearch } from '../../../data/public';
-import { VegaInspectorAdapters } from '../vega_inspector';
-import { RequestResponder } from '../../../inspector/public';
+import type { VegaInspectorAdapters } from '../vega_inspector';
+import type { RequestResponder } from '../../../inspector/public';
 
-const extendSearchParamsWithRuntimeFields = async (
+/** @internal **/
+export const extendSearchParamsWithRuntimeFields = async (
+  indexPatterns: SearchAPIDependencies['indexPatterns'],
   requestParams: ReturnType<typeof getSearchParamsFromRequest>,
   indexPatternString?: string
 ) => {
   if (indexPatternString) {
-    const indexPattern = (await getData().indexPatterns.find(indexPatternString)).find(
-      (index) => index.title === indexPatternString
-    );
-    const runtimeFields = indexPattern?.getComputedFields().runtimeFields;
+    let runtimeMappings = requestParams.body?.runtime_mappings;
+
+    if (!runtimeMappings) {
+      const indexPattern = (await indexPatterns.find(indexPatternString)).find(
+        (index) => index.title === indexPatternString
+      );
+      runtimeMappings = indexPattern?.getComputedFields().runtimeFields;
+    }
 
     return {
       ...requestParams,
-      body: { ...requestParams.body, runtime_mappings: runtimeFields },
+      body: { ...requestParams.body, runtime_mappings: runtimeMappings },
     };
   }
 
@@ -43,6 +48,7 @@ export interface SearchAPIDependencies {
   uiSettings: IUiSettingsClient;
   injectedMetadata: CoreStart['injectedMetadata'];
   search: DataPublicPluginStart['search'];
+  indexPatterns: DataPublicPluginStart['indexPatterns'];
 }
 
 export class SearchAPI {
@@ -54,7 +60,7 @@ export class SearchAPI {
   ) {}
 
   search(searchRequests: SearchRequest[]) {
-    const { search } = this.dependencies;
+    const { search, indexPatterns } = this.dependencies;
     const requestResponders: any = {};
 
     return combineLatest(
@@ -64,15 +70,19 @@ export class SearchAPI {
           getConfig: this.dependencies.uiSettings.get.bind(this.dependencies.uiSettings),
         });
 
-        if (this.inspectorAdapters) {
-          requestResponders[requestId] = this.inspectorAdapters.requests.start(requestId, {
-            ...request,
-            searchSessionId: this.searchSessionId,
-          });
-          requestResponders[requestId].json(requestParams.body);
-        }
-
-        return from(extendSearchParamsWithRuntimeFields(requestParams, request.index)).pipe(
+        return from(
+          extendSearchParamsWithRuntimeFields(indexPatterns, requestParams, request.index)
+        ).pipe(
+          tap((params) => {
+            /** inspect request data **/
+            if (this.inspectorAdapters) {
+              requestResponders[requestId] = this.inspectorAdapters.requests.start(requestId, {
+                ...request,
+                searchSessionId: this.searchSessionId,
+              });
+              requestResponders[requestId].json(params.body);
+            }
+          }),
           switchMap((params) =>
             search
               .search(