Fixed conflicts (#89631)

Author: YulNaumenko

x-pack/plugins/event_log/server/es/cluster_client_adapter.test.ts

@@ -5,20 +5,18 @@
  */
 
 import { Subject } from 'rxjs';
-import { bufferTime, filter, switchMap } from 'rxjs/operators';
+import { bufferTime, filter as rxFilter, switchMap } from 'rxjs/operators';
 import { reject, isUndefined } from 'lodash';
-import { Client } from 'elasticsearch';
 import type { PublicMethodsOf } from '@kbn/utility-types';
-import { Logger, LegacyClusterClient } from 'src/core/server';
-import { ESSearchResponse } from '../../../../typings/elasticsearch';
+import { Logger, ElasticsearchClient } from 'src/core/server';
 import { EsContext } from '.';
 import { IEvent, IValidatedEvent, SAVED_OBJECT_REL_PRIMARY } from '../types';
 import { FindOptionsType } from '../event_log_client';
+import { esKuery } from '../../../../../src/plugins/data/server';
 
 export const EVENT_BUFFER_TIME = 1000; // milliseconds
 export const EVENT_BUFFER_LENGTH = 100;
 
-export type EsClusterClient = Pick<LegacyClusterClient, 'callAsInternalUser' | 'asScoped'>;
 export type IClusterClientAdapter = PublicMethodsOf<ClusterClientAdapter>;
 
 export interface Doc {
@@ -28,7 +26,7 @@ export interface Doc {
 
 export interface ConstructorOpts {
   logger: Logger;
-  clusterClientPromise: Promise<EsClusterClient>;
+  elasticsearchClientPromise: Promise<ElasticsearchClient>;
   context: EsContext;
 }
 
@@ -41,14 +39,14 @@ export interface QueryEventsBySavedObjectResult {
 
 export class ClusterClientAdapter {
   private readonly logger: Logger;
-  private readonly clusterClientPromise: Promise<EsClusterClient>;
+  private readonly elasticsearchClientPromise: Promise<ElasticsearchClient>;
   private readonly docBuffer$: Subject<Doc>;
   private readonly context: EsContext;
   private readonly docsBufferedFlushed: Promise<void>;
 
   constructor(opts: ConstructorOpts) {
     this.logger = opts.logger;
-    this.clusterClientPromise = opts.clusterClientPromise;
+    this.elasticsearchClientPromise = opts.elasticsearchClientPromise;
     this.context = opts.context;
     this.docBuffer$ = new Subject<Doc>();
 
@@ -58,7 +56,7 @@ export class ClusterClientAdapter {
     this.docsBufferedFlushed = this.docBuffer$
       .pipe(
         bufferTime(EVENT_BUFFER_TIME, null, EVENT_BUFFER_LENGTH),
-        filter((docs) => docs.length > 0),
+        rxFilter((docs) => docs.length > 0),
         switchMap(async (docs) => await this.indexDocuments(docs))
       )
       .toPromise();
@@ -97,7 +95,8 @@ export class ClusterClientAdapter {
     }
 
     try {
-      await this.callEs<ReturnType<Client['bulk']>>('bulk', { body: bulkBody });
+      const esClient = await this.elasticsearchClientPromise;
+      await esClient.bulk({ body: bulkBody });
     } catch (err) {
       this.logger.error(
         `error writing bulk events: "${err.message}"; docs: ${JSON.stringify(bulkBody)}`
@@ -111,22 +110,24 @@ export class ClusterClientAdapter {
       path: `/_ilm/policy/${policyName}`,
     };
     try {
-      await this.callEs('transport.request', request);
+      const esClient = await this.elasticsearchClientPromise;
+      await esClient.transport.request(request);
     } catch (err) {
       if (err.statusCode === 404) return false;
       throw new Error(`error checking existance of ilm policy: ${err.message}`);
     }
     return true;
   }
 
-  public async createIlmPolicy(policyName: string, policy: unknown): Promise<void> {
+  public async createIlmPolicy(policyName: string, policy: Record<string, unknown>): Promise<void> {
     const request = {
       method: 'PUT',
       path: `/_ilm/policy/${policyName}`,
       body: policy,
     };
     try {
-      await this.callEs('transport.request', request);
+      const esClient = await this.elasticsearchClientPromise;
+      await esClient.transport.request(request);
     } catch (err) {
       throw new Error(`error creating ilm policy: ${err.message}`);
     }
@@ -135,27 +136,18 @@ export class ClusterClientAdapter {
   public async doesIndexTemplateExist(name: string): Promise<boolean> {
     let result;
     try {
-      result = await this.callEs<ReturnType<Client['indices']['existsTemplate']>>(
-        'indices.existsTemplate',
-        { name }
-      );
+      const esClient = await this.elasticsearchClientPromise;
+      result = (await esClient.indices.existsTemplate({ name })).body;
     } catch (err) {
       throw new Error(`error checking existance of index template: ${err.message}`);
     }
     return result as boolean;
   }
 
-  public async createIndexTemplate(name: string, template: unknown): Promise<void> {
-    const addTemplateParams = {
-      name,
-      create: true,
-      body: template,
-    };
+  public async createIndexTemplate(name: string, template: Record<string, unknown>): Promise<void> {
     try {
-      await this.callEs<ReturnType<Client['indices']['putTemplate']>>(
-        'indices.putTemplate',
-        addTemplateParams
-      );
+      const esClient = await this.elasticsearchClientPromise;
+      await esClient.indices.putTemplate({ name, body: template, create: true });
     } catch (err) {
       // The error message doesn't have a type attribute we can look to guarantee it's due
       // to the template already existing (only long message) so we'll check ourselves to see
@@ -171,19 +163,21 @@ export class ClusterClientAdapter {
   public async doesAliasExist(name: string): Promise<boolean> {
     let result;
     try {
-      result = await this.callEs<ReturnType<Client['indices']['existsAlias']>>(
-        'indices.existsAlias',
-        { name }
-      );
+      const esClient = await this.elasticsearchClientPromise;
+      result = (await esClient.indices.existsAlias({ name })).body;
     } catch (err) {
       throw new Error(`error checking existance of initial index: ${err.message}`);
     }
     return result as boolean;
   }
 
-  public async createIndex(name: string, body: unknown = {}): Promise<void> {
+  public async createIndex(
+    name: string,
+    body: string | Record<string, unknown> = {}
+  ): Promise<void> {
     try {
-      await this.callEs<ReturnType<Client['indices']['create']>>('indices.create', {
+      const esClient = await this.elasticsearchClientPromise;
+      await esClient.indices.create({
         index: name,
         body,
       });
@@ -200,7 +194,7 @@ export class ClusterClientAdapter {
     type: string,
     ids: string[],
     // eslint-disable-next-line @typescript-eslint/naming-convention
-    { page, per_page: perPage, start, end, sort_field, sort_order }: FindOptionsType
+    { page, per_page: perPage, start, end, sort_field, sort_order, filter }: FindOptionsType
   ): Promise<QueryEventsBySavedObjectResult> {
     const defaultNamespaceQuery = {
       bool: {
@@ -220,12 +214,26 @@ export class ClusterClientAdapter {
     };
     const namespaceQuery = namespace === undefined ? defaultNamespaceQuery : namedNamespaceQuery;
 
+    const esClient = await this.elasticsearchClientPromise;
+    let dslFilterQuery;
+    try {
+      dslFilterQuery = filter
+        ? esKuery.toElasticsearchQuery(esKuery.fromKueryExpression(filter))
+        : [];
+    } catch (err) {
+      this.debug(`Invalid kuery syntax for the filter (${filter}) error:`, {
+        message: err.message,
+        statusCode: err.statusCode,
+      });
+      throw err;
+    }
     const body = {
       size: perPage,
       from: (page - 1) * perPage,
       sort: { [sort_field]: { order: sort_order } },
       query: {
         bool: {
+          filter: dslFilterQuery,
           must: reject(
             [
               {
@@ -283,8 +291,10 @@ export class ClusterClientAdapter {
 
     try {
       const {
-        hits: { hits, total },
-      }: ESSearchResponse<unknown, {}> = await this.callEs('search', {
+        body: {
+          hits: { hits, total },
+        },
+      } = await esClient.search({
         index,
         track_total_hits: true,
         body,
@@ -293,7 +303,7 @@ export class ClusterClientAdapter {
         page,
         per_page: perPage,
         total: total.value,
-        data: hits.map((hit) => hit._source) as IValidatedEvent[],
+        data: hits.map((hit: { _source: unknown }) => hit._source) as IValidatedEvent[],
       };
     } catch (err) {
       throw new Error(
@@ -302,24 +312,6 @@ export class ClusterClientAdapter {
     }
   }
 
-  // We have a common problem typing ES-DSL Queries
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private async callEs<ESQueryResult = unknown>(operation: string, body?: any) {
-    try {
-      this.debug(`callEs(${operation}) calls:`, body);
-      const clusterClient = await this.clusterClientPromise;
-      const result = await clusterClient.callAsInternalUser(operation, body);
-      this.debug(`callEs(${operation}) result:`, result);
-      return result as ESQueryResult;
-    } catch (err) {
-      this.debug(`callEs(${operation}) error:`, {
-        message: err.message,
-        statusCode: err.statusCode,
-      });
-      throw err;
-    }
-  }
-
   private debug(message: string, object?: unknown) {
     const objectString = object == null ? '' : JSON.stringify(object);
     this.logger.debug(`esContext: ${message} ${objectString}`);

x-pack/plugins/event_log/server/es/cluster_client_adapter.ts

@@ -5,27 +5,28 @@
  */
 
 import { createEsContext } from './context';
-import { LegacyClusterClient, Logger } from '../../../../../src/core/server';
+import { ElasticsearchClient, Logger } from '../../../../../src/core/server';
 import { elasticsearchServiceMock, loggingSystemMock } from '../../../../../src/core/server/mocks';
+import { DeeplyMockedKeys } from '@kbn/utility-types/jest';
+import { RequestEvent } from '@elastic/elasticsearch';
 jest.mock('../lib/../../../../package.json', () => ({ version: '1.2.3' }));
 jest.mock('./init');
-type EsClusterClient = Pick<jest.Mocked<LegacyClusterClient>, 'callAsInternalUser' | 'asScoped'>;
 
 let logger: Logger;
-let clusterClient: EsClusterClient;
+let elasticsearchClient: DeeplyMockedKeys<ElasticsearchClient>;
 
 beforeEach(() => {
   logger = loggingSystemMock.createLogger();
-  clusterClient = elasticsearchServiceMock.createLegacyClusterClient();
+  elasticsearchClient = elasticsearchServiceMock.createClusterClient().asInternalUser;
 });
 
 describe('createEsContext', () => {
   test('should return is ready state as falsy if not initialized', () => {
     const context = createEsContext({
       logger,
-      clusterClientPromise: Promise.resolve(clusterClient),
       indexNameRoot: 'test0',
       kibanaVersion: '1.2.3',
+      elasticsearchClientPromise: Promise.resolve(elasticsearchClient),
     });
 
     expect(context.initialized).toBeFalsy();
@@ -37,9 +38,9 @@ describe('createEsContext', () => {
   test('should return esNames', () => {
     const context = createEsContext({
       logger,
-      clusterClientPromise: Promise.resolve(clusterClient),
       indexNameRoot: 'test-index',
       kibanaVersion: '1.2.3',
+      elasticsearchClientPromise: Promise.resolve(elasticsearchClient),
     });
 
     const esNames = context.esNames;
@@ -57,12 +58,12 @@ describe('createEsContext', () => {
   test('should return exist false for esAdapter ilm policy, index template and alias before initialize', async () => {
     const context = createEsContext({
       logger,
-      clusterClientPromise: Promise.resolve(clusterClient),
       indexNameRoot: 'test1',
       kibanaVersion: '1.2.3',
+      elasticsearchClientPromise: Promise.resolve(elasticsearchClient),
     });
-    (clusterClient.callAsInternalUser as jest.Mock).mockResolvedValue(false);
-
+    elasticsearchClient.indices.existsTemplate.mockResolvedValue(asApiResponse(false));
+    elasticsearchClient.indices.existsAlias.mockResolvedValue(asApiResponse(false));
     const doesAliasExist = await context.esAdapter.doesAliasExist(context.esNames.alias);
     expect(doesAliasExist).toBeFalsy();
 
@@ -75,11 +76,11 @@ describe('createEsContext', () => {
   test('should return exist true for esAdapter ilm policy, index template and alias after initialize', async () => {
     const context = createEsContext({
       logger,
-      clusterClientPromise: Promise.resolve(clusterClient),
       indexNameRoot: 'test2',
       kibanaVersion: '1.2.3',
+      elasticsearchClientPromise: Promise.resolve(elasticsearchClient),
     });
-    (clusterClient.callAsInternalUser as jest.Mock).mockResolvedValue(true);
+    elasticsearchClient.indices.existsTemplate.mockResolvedValue(asApiResponse(true));
     context.initialize();
 
     const doesIlmPolicyExist = await context.esAdapter.doesIlmPolicyExist(
@@ -100,12 +101,18 @@ describe('createEsContext', () => {
     jest.requireMock('./init').initializeEs.mockResolvedValue(false);
     const context = createEsContext({
       logger,
-      clusterClientPromise: Promise.resolve(clusterClient),
       indexNameRoot: 'test2',
       kibanaVersion: '1.2.3',
+      elasticsearchClientPromise: Promise.resolve(elasticsearchClient),
     });
     context.initialize();
     const success = await context.waitTillReady();
     expect(success).toBe(false);
   });
 });
+
+function asApiResponse<T>(body: T): RequestEvent<T> {
+  return {
+    body,
+  } as RequestEvent<T>;
+}

x-pack/plugins/event_log/server/es/context.test.ts

@@ -4,15 +4,13 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 
-import { Logger, LegacyClusterClient } from 'src/core/server';
+import { Logger, ElasticsearchClient } from 'src/core/server';
 
 import { EsNames, getEsNames } from './names';
 import { initializeEs } from './init';
 import { ClusterClientAdapter, IClusterClientAdapter } from './cluster_client_adapter';
 import { createReadySignal, ReadySignal } from '../lib/ready_signal';
 
-export type EsClusterClient = Pick<LegacyClusterClient, 'callAsInternalUser' | 'asScoped'>;
-
 export interface EsContext {
   logger: Logger;
   esNames: EsNames;
@@ -34,9 +32,9 @@ export function createEsContext(params: EsContextCtorParams): EsContext {
 
 export interface EsContextCtorParams {
   logger: Logger;
-  clusterClientPromise: Promise<EsClusterClient>;
   indexNameRoot: string;
   kibanaVersion: string;
+  elasticsearchClientPromise: Promise<ElasticsearchClient>;
 }
 
 class EsContextImpl implements EsContext {
@@ -53,7 +51,7 @@ class EsContextImpl implements EsContext {
     this.initialized = false;
     this.esAdapter = new ClusterClientAdapter({
       logger: params.logger,
-      clusterClientPromise: params.clusterClientPromise,
+      elasticsearchClientPromise: params.elasticsearchClientPromise,
       context: this,
     });
   }

x-pack/plugins/event_log/server/es/context.ts

@@ -4,4 +4,4 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 
-export { EsClusterClient, EsContext, createEsContext } from './context';
+export { EsContext, createEsContext } from './context';