[ResponseOps] Add pagination and sorting to the alerts search strategy

x-pack/plugins/rule_registry/common/search_strategy/index.ts

@@ -12,8 +12,15 @@ import { IEsSearchRequest, IEsSearchResponse } from 'src/plugins/data/common';
 export type RuleRegistrySearchRequest = IEsSearchRequest & {
   featureIds: ValidFeatureId[];
   query?: { bool: estypes.QueryDslBoolQuery };
+  sort?: estypes.SortCombinations[];
+  pagination?: RuleRegistrySearchRequestPagination;
 };
 
+export interface RuleRegistrySearchRequestPagination {
+  pageIndex: number;
+  pageSize: number;
+}
+
 type Prev = [
   never,
   0,

x-pack/plugins/rule_registry/server/search_strategy/search_strategy.test.ts

@@ -68,6 +68,7 @@ describe('ruleRegistrySearchStrategyProvider()', () => {
   });
 
   let getAuthzFilterSpy: jest.SpyInstance;
+  const search = jest.fn().mockImplementation(() => of(response));
 
   beforeEach(() => {
     ruleDataService.findIndicesByFeature.mockImplementation(() => {
@@ -80,7 +81,7 @@ describe('ruleRegistrySearchStrategyProvider()', () => {
 
     data.search.getSearchStrategy.mockImplementation(() => {
       return {
-        search: () => of(response),
+        search,
       };
     });
 
@@ -95,6 +96,7 @@ describe('ruleRegistrySearchStrategyProvider()', () => {
     ruleDataService.findIndicesByFeature.mockClear();
     data.search.getSearchStrategy.mockClear();
     getAuthzFilterSpy.mockClear();
+    search.mockClear();
   });
 
   it('should handle a basic search request', async () => {
@@ -199,4 +201,66 @@ describe('ruleRegistrySearchStrategyProvider()', () => {
       .toPromise();
     expect(result).toBe(EMPTY_RESPONSE);
   });
+
+  it('should support pagination', async () => {
+    const request: RuleRegistrySearchRequest = {
+      featureIds: [AlertConsumers.LOGS],
+      pagination: {
+        pageSize: 10,
+        pageIndex: 1,
+      },
+    };
+    const options = {};
+    const deps = {
+      request: {},
+    };
+
+    const strategy = ruleRegistrySearchStrategyProvider(
+      data,
+      ruleDataService,
+      alerting,
+      logger,
+      security,
+      spaces
+    );
+
+    await strategy
+      .search(request, options, deps as unknown as SearchStrategyDependencies)
+      .toPromise();
+    expect(search.mock.calls.length).toBe(1);
+    expect(search.mock.calls[0][0].params.body.size).toBe(10);
+    expect(search.mock.calls[0][0].params.body.from).toBe(10);
+  });
+
+  it('should support sorting', async () => {
+    const request: RuleRegistrySearchRequest = {
+      featureIds: [AlertConsumers.LOGS],
+      sort: [
+        {
+          test: {
+            order: 'desc',
+          },
+        },
+      ],
+    };
+    const options = {};
+    const deps = {
+      request: {},
+    };
+
+    const strategy = ruleRegistrySearchStrategyProvider(
+      data,
+      ruleDataService,
+      alerting,
+      logger,
+      security,
+      spaces
+    );
+
+    await strategy
+      .search(request, options, deps as unknown as SearchStrategyDependencies)
+      .toPromise();
+    expect(search.mock.calls.length).toBe(1);
+    expect(search.mock.calls[0][0].params.body.sort).toStrictEqual([{ test: { order: 'desc' } }]);
+  });
 });

x-pack/plugins/rule_registry/server/search_strategy/search_strategy.ts

@@ -91,18 +91,23 @@ export const ruleRegistrySearchStrategyProvider = (
             filter.push(getSpacesFilter(space.id) as estypes.QueryDslQueryContainer);
           }
 
+          const sort = request.sort ?? [];
+
           const query = {
             bool: {
               ...request.query?.bool,
               filter,
             },
           };
+          const size = request.pagination ? request.pagination.pageSize : MAX_ALERT_SEARCH_SIZE;
           const params = {
             index: indices,
             body: {
               _source: false,
               fields: ['*'],
-              size: MAX_ALERT_SEARCH_SIZE,
+              sort,
+              size,
+              from: request.pagination ? request.pagination.pageIndex * size : 0,
               query,
             },
           };

x-pack/test/rule_registry/security_and_spaces/tests/basic/search_strategy.ts

@@ -35,9 +35,11 @@ export default ({ getService }: FtrProviderContext) => {
       beforeEach(async () => {
         await esArchiver.load('x-pack/test/functional/es_archives/observability/alerts');
       });
+
       afterEach(async () => {
         await esArchiver.unload('x-pack/test/functional/es_archives/observability/alerts');
       });
+
       it('should return alerts from log rules', async () => {
         const result = await bsearch.send<RuleRegistrySearchResponse>({
           supertest,
@@ -52,6 +54,32 @@ export default ({ getService }: FtrProviderContext) => {
         });
         expect(consumers.every((consumer) => consumer === AlertConsumers.LOGS));
       });
+
+      it('should support pagination and sorting', async () => {
+        const result = await bsearch.send<RuleRegistrySearchResponse>({
+          supertest,
+          options: {
+            featureIds: [AlertConsumers.LOGS],
+            pagination: {
+              pageSize: 2,
+              pageIndex: 1,
+            },
+            sort: [
+              {
+                'kibana.alert.evaluation.value': {
+                  order: 'desc',
+                },
+              },
+            ],
+          },
+          strategy: 'ruleRegistryAlertsSearchStrategy',
+        });
+        expect(result.rawResponse.hits.total).to.eql(5);
+        expect(result.rawResponse.hits.hits.length).to.eql(2);
+        const first = result.rawResponse.hits.hits[0].fields?.['kibana.alert.evaluation.value'];
+        const second = result.rawResponse.hits.hits[1].fields?.['kibana.alert.evaluation.value'];
+        expect(first > second).to.be(true);
+      });
     });
 
     describe('siem', () => {