Merge branch 'main' into fe/feature/RI-3804_optimize-ls

# Conflicts:
#	redisinsight/ui/src/slices/app/context.ts

Author: rsergeenko

.gitignore

@@ -46,6 +46,10 @@ renderer.prod.js.map
 redisinsight/ui/style.css
 redisinsight/ui/style.css.map
 redisinsight/ui/dist
+redisinsight/api/commands
+redisinsight/api/guides
+redisinsight/api/tutorials
+redisinsight/api/content
 dist
 distWeb
 dll

redisinsight/api/src/constants/error-messages.ts

@@ -52,4 +52,5 @@ export default {
   REDIS_MODULE_IS_REQUIRED: (module: string) => `Required ${module} module is not loaded.`,
   APP_SETTINGS_NOT_FOUND: () => 'Could not find application settings.',
   SERVER_INFO_NOT_FOUND: () => 'Could not find server info.',
+  INCREASE_MINIMUM_LIMIT: (count: string) => `Set MAXSEARCHRESULTS to at least ${count}.`,
 };

redisinsight/api/src/constants/redis-error-codes.ts

@@ -13,6 +13,7 @@ export enum RedisErrorCodes {
   BusyGroup = 'BUSYGROUP',
   NoGroup = 'NOGROUP',
   UnknownCommand = 'unknown command',
+  RedisearchLimit = 'LIMIT',
 }
 
 export enum CertificatesErrorCodes {

redisinsight/api/src/modules/browser/dto/keys.dto.ts

@@ -319,4 +319,12 @@ export class GetKeysWithDetailsResponse {
     description: 'Node port. In case when we are working with cluster',
   })
   port?: number;
+
+  @ApiPropertyOptional({
+    type: Number,
+    description:
+      'The maximum number of results.'
+      + ' For RediSearch this number is a value from "FT.CONFIG GET maxsearchresults" command.'
+  })
+  maxResults?: number;
 }

redisinsight/api/src/modules/browser/services/redisearch/redisearch.service.spec.ts

@@ -222,14 +222,15 @@ describe('RedisearchService', () => {
         cursor: mockSearchRedisearchDto.limit + mockSearchRedisearchDto.offset,
         scanned: 2,
         total: 100,
+        maxResults: null,
         keys: [{
           name: keyName1,
         }, {
           name: keyName2,
         }],
       });
 
-      expect(nodeClient.sendCommand).toHaveBeenCalledTimes(1);
+      expect(nodeClient.sendCommand).toHaveBeenCalledTimes(2);
       expect(nodeClient.sendCommand).toHaveBeenCalledWith(jasmine.objectContaining({
         name: 'FT.SEARCH',
         args: [
@@ -239,6 +240,13 @@ describe('RedisearchService', () => {
           'LIMIT', `${mockSearchRedisearchDto.offset}`, `${mockSearchRedisearchDto.limit}`,
         ],
       }));
+      expect(nodeClient.sendCommand).toHaveBeenCalledWith(jasmine.objectContaining( {
+        name: 'FT.CONFIG',
+        args: [
+          'GET',
+          'MAXSEARCHRESULTS',
+        ],
+      }));
     });
     it('should search in cluster', async () => {
       browserTool.getRedisClient.mockResolvedValue(clusterClient);
@@ -252,13 +260,14 @@ describe('RedisearchService', () => {
         cursor: mockSearchRedisearchDto.limit + mockSearchRedisearchDto.offset,
         scanned: 2,
         total: 100,
+        maxResults: null,
         keys: [
           { name: keyName1 },
           { name: keyName2 },
         ],
       });
 
-      expect(clusterClient.sendCommand).toHaveBeenCalledTimes(1);
+      expect(clusterClient.sendCommand).toHaveBeenCalledTimes(2);
       expect(clusterClient.sendCommand).toHaveBeenCalledWith(jasmine.objectContaining({
         name: 'FT.SEARCH',
         args: [
@@ -268,6 +277,13 @@ describe('RedisearchService', () => {
           'LIMIT', `${mockSearchRedisearchDto.offset}`, `${mockSearchRedisearchDto.limit}`,
         ],
       }));
+      expect(clusterClient.sendCommand).toHaveBeenCalledWith(jasmine.objectContaining( {
+        name: 'FT.CONFIG',
+        args: [
+          'GET',
+          'MAXSEARCHRESULTS',
+        ],
+      }));
     });
     it('should handle ACL error (ft.info command)', async () => {
       when(nodeClient.sendCommand)

redisinsight/api/src/modules/browser/services/redisearch/redisearch.service.ts

@@ -1,6 +1,7 @@
 import { Cluster, Command, Redis } from 'ioredis';
-import { uniq } from 'lodash';
+import { toNumber, uniq } from 'lodash';
 import {
+  BadRequestException,
   ConflictException,
   Injectable,
   Logger,
@@ -14,7 +15,9 @@ import {
   SearchRedisearchDto,
 } from 'src/modules/browser/dto/redisearch';
 import { GetKeysWithDetailsResponse } from 'src/modules/browser/dto';
+import { RedisErrorCodes } from 'src/constants';
 import { plainToClass } from 'class-transformer';
+import { numberWithSpaces } from 'src/utils/base.helper';
 import { BrowserToolService } from '../browser-tool/browser-tool.service';
 
 @Injectable()
@@ -137,6 +140,7 @@ export class RedisearchService {
     this.logger.log('Searching keys using redisearch.');
 
     try {
+      let maxResults;
       const {
         index, query, offset, limit,
       } = dto;
@@ -147,16 +151,33 @@ export class RedisearchService {
         new Command('FT.SEARCH', [index, query, 'NOCONTENT', 'LIMIT', offset, limit]),
       );
 
+
+      try {
+        const [[, maxSearchResults]] = await client.sendCommand(
+          // response: [ [ 'MAXSEARCHRESULTS', '10000' ] ]
+          new Command('FT.CONFIG', ['GET', 'MAXSEARCHRESULTS'], {
+            replyEncoding: 'utf8',
+          }),
+        ) as [[string, string]];
+
+        maxResults = toNumber(maxSearchResults);
+      } catch (error) {
+        maxResults = null;
+      }
+
       return plainToClass(GetKeysWithDetailsResponse, {
         cursor: limit + offset,
         total,
         scanned: keyNames.length + offset,
         keys: keyNames.map((name) => ({ name })),
+        maxResults,
       });
-    } catch (e) {
-      this.logger.error('Failed to search keys using redisearch index', e);
-
-      throw catchAclError(e);
+    } catch (error) {
+      this.logger.error('Failed to search keys using redisearch index', error);
+      if (error.message?.includes(RedisErrorCodes.RedisearchLimit)) {
+        throw new BadRequestException(ERROR_MESSAGES.INCREASE_MINIMUM_LIMIT(numberWithSpaces(dto.limit)));
+      }
+      throw catchAclError(error);
     }
   }
 

redisinsight/api/src/utils/base.helper.spec.ts

@@ -0,0 +1,23 @@
+import { numberWithSpaces } from 'src/utils/base.helper';
+
+const numberWithSpacesTests = [
+  { input: 0, output: '0' },
+  { input: 10, output: '10' },
+  { input: 100, output: '100' },
+  { input: 1000, output: '1 000' },
+  { input: 1000.001, output: '1 000.001' },
+  { input: 5500, output: '5 500' },
+  { input: 1000000, output: '1 000 000' },
+  { input: 1233543234543243, output: '1 233 543 234 543 243' },
+  { input: NaN, output: 'NaN' },
+];
+
+describe('numberWithSpaces', () => {
+  numberWithSpacesTests.forEach((test) => {
+    it(`should be output: ${test.output} for input: ${test.input} `, async () => {
+      const result = numberWithSpaces(test.input);
+
+      expect(result).toEqual(test.output);
+    });
+  });
+});

redisinsight/api/src/utils/base.helper.ts

@@ -4,3 +4,7 @@ export const sortByNumberField = <T>(
   items: T[],
   field: string,
 ): T[] => sortBy(items, (o) => (o && isNumber(o[field]) ? o[field] : -Infinity));
+
+
+export const numberWithSpaces = (number: number = 0) =>
+  number.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ' ')

redisinsight/api/test/api/redisearch/POST-databases-id-redisearch-search.test.ts

@@ -1,3 +1,4 @@
+import { numberWithSpaces } from 'src/utils/base.helper';
 import {
   expect,
   describe,
@@ -34,6 +35,7 @@ const responseSchema = Joi.object({
   cursor: Joi.number().integer().required(),
   scanned: Joi.number().integer().required(),
   total: Joi.number().integer().required(),
+  maxResults: Joi.number().integer().allow(null).required(),
   keys: Joi.array().items(Joi.object({
     name: JoiRedisString.required(),
   })).required(),
@@ -62,6 +64,7 @@ describe('POST /databases/:id/redisearch/search', () => {
             expect(body.cursor).to.eq(10);
             expect(body.scanned).to.eq(10);
             expect(body.total).to.eq(2000);
+            expect(body.maxResults).to.eq(10000);
           },
         },
         {
@@ -77,8 +80,21 @@ describe('POST /databases/:id/redisearch/search', () => {
             expect(body.cursor).to.eq(110);
             expect(body.scanned).to.eq(110);
             expect(body.total).to.eq(2000);
+            expect(body.maxResults).to.eq(10000);
           },
         },
+        {
+          name: 'Should return custom error message if MAXSEARCHRESULTS less than request.limit',
+          data: validInputData,
+          statusCode: 400,
+          responseBody: {
+            statusCode: 400,
+            error: 'Bad Request',
+            message: `Set MAXSEARCHRESULTS to at least ${numberWithSpaces(validInputData.limit)}.`,
+          },
+          before: () => rte.data.setRedisearchConfig('MAXSEARCHRESULTS', '1'),
+          after: () => rte.data.setRedisearchConfig('MAXSEARCHRESULTS', '10000'),
+        },
       ].map(mainCheckFn);
     });
 
@@ -107,6 +123,20 @@ describe('POST /databases/:id/redisearch/search', () => {
           },
           before: () => rte.data.setAclUserRules('~* +@all -ft.search')
         },
+        {
+          name: 'Should return response with maxResults = null if no permissions for "ft.config" command',
+          endpoint: () => endpoint(constants.TEST_INSTANCE_ACL_ID),
+          data: validInputData,
+          responseSchema,
+          checkFn: async ({ body }) => {
+            expect(body.keys.length).to.eq(10);
+            expect(body.cursor).to.eq(10);
+            expect(body.scanned).to.eq(10);
+            expect(body.total).to.eq(2000);
+            expect(body.maxResults).to.eq(null);
+          },
+          before: () => rte.data.setAclUserRules('~* +@all -ft.config')
+        },
       ].map(mainCheckFn);
     });
   });

redisinsight/api/test/helpers/data/redis.ts

@@ -456,6 +456,15 @@ export const initDataHelper = (rte) => {
     }
   }
 
+  const setRedisearchConfig = async (
+    rule: string,
+    value: string,
+  ): Promise<any> => {
+    const command = `FT.CONFIG SET ${rule} ${value}`;
+
+    return executeCommand(...command.split(' '));
+  };
+
   return {
     sendCommand,
     executeCommand,
@@ -477,5 +486,6 @@ export const initDataHelper = (rte) => {
     generateNStreams,
     generateNGraphs,
     getClientNodes,
+    setRedisearchConfig,
   }
 }