Feature/ri 2831 browser redisearch

redisinsight/api/src/__mocks__/errors.ts

@@ -6,6 +6,12 @@ export const mockRedisNoPermError: ReplyError = {
   message: 'NOPERM this user has no permissions.',
 };
 
+export const mockRedisUnknownIndexName: ReplyError = {
+  name: 'ReplyError',
+  command: 'FT.INFO',
+  message: 'Unknown Index name',
+};
+
 export const mockRedisWrongNumberOfArgumentsError: ReplyError = {
   name: 'ReplyError',
   command: 'GET',

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

@@ -23,6 +23,7 @@ export default {
   MASTER_GROUP_NOT_EXIST: "Master group with this name doesn't exist",
 
   KEY_NAME_EXIST: 'This key name is already in use.',
+  REDISEARCH_INDEX_EXIST: 'This index name is already in use.',
   KEY_NOT_EXIST: 'Key with this name does not exist.',
   PATH_NOT_EXISTS: () => 'There is no such path.',
   INDEX_OUT_OF_RANGE: () => 'Index is out of range.',

redisinsight/api/src/modules/browser/browser.module.ts

@@ -8,6 +8,8 @@ import { ConsumerGroupController } from 'src/modules/browser/controllers/stream/
 import { ConsumerGroupService } from 'src/modules/browser/services/stream/consumer-group.service';
 import { ConsumerController } from 'src/modules/browser/controllers/stream/consumer.controller';
 import { ConsumerService } from 'src/modules/browser/services/stream/consumer.service';
+import { RedisearchController } from 'src/modules/browser/controllers/redisearch/redisearch.controller';
+import { RedisearchService } from 'src/modules/browser/services/redisearch/redisearch.service';
 import { HashController } from './controllers/hash/hash.controller';
 import { KeysController } from './controllers/keys/keys.controller';
 import { KeysBusinessService } from './services/keys-business/keys-business.service';
@@ -34,6 +36,7 @@ import { BrowserToolClusterService } from './services/browser-tool-cluster/brows
     SetController,
     ZSetController,
     RejsonRlController,
+    RedisearchController,
     HashController,
     StreamController,
     ConsumerGroupController,
@@ -46,6 +49,7 @@ import { BrowserToolClusterService } from './services/browser-tool-cluster/brows
     SetBusinessService,
     ZSetBusinessService,
     RejsonRlBusinessService,
+    RedisearchService,
     HashBusinessService,
     StreamService,
     ConsumerGroupService,

redisinsight/api/src/modules/browser/controllers/redisearch/redisearch.controller.ts

@@ -0,0 +1,81 @@
+import {
+  Body,
+  Controller,
+  Get, HttpCode,
+  Param,
+  Post,
+} from '@nestjs/common';
+import {
+  ApiBody,
+  ApiOkResponse,
+  ApiOperation,
+  ApiTags,
+} from '@nestjs/swagger';
+import { ApiRedisParams } from 'src/decorators/api-redis-params.decorator';
+import { ApiQueryRedisStringEncoding } from 'src/common/decorators';
+import { BaseController } from 'src/modules/browser/controllers/base.controller';
+import {
+  CreateRedisearchIndexDto,
+  ListRedisearchIndexesResponse,
+  SearchRedisearchDto,
+} from 'src/modules/browser/dto/redisearch';
+import { RedisearchService } from 'src/modules/browser/services/redisearch/redisearch.service';
+import { GetKeysWithDetailsResponse } from 'src/modules/browser/dto';
+
+@ApiTags('RediSearch')
+@Controller('redisearch')
+export class RedisearchController extends BaseController {
+  constructor(private service: RedisearchService) {
+    super();
+  }
+
+  @Get('')
+  @ApiOperation({ description: 'Get list of available indexes' })
+  @ApiOkResponse({ type: ListRedisearchIndexesResponse })
+  @ApiRedisParams()
+  @ApiQueryRedisStringEncoding()
+  async list(
+    @Param('dbInstance') dbInstance: string,
+  ): Promise<ListRedisearchIndexesResponse> {
+    return this.service.list(
+      {
+        instanceId: dbInstance,
+      },
+    );
+  }
+
+  @Post('')
+  @ApiOperation({ description: 'Create redisearch index' })
+  @ApiRedisParams()
+  @HttpCode(201)
+  @ApiBody({ type: CreateRedisearchIndexDto })
+  async createIndex(
+    @Param('dbInstance') dbInstance: string,
+      @Body() dto: CreateRedisearchIndexDto,
+  ): Promise<void> {
+    return await this.service.createIndex(
+      {
+        instanceId: dbInstance,
+      },
+      dto,
+    );
+  }
+
+  @Post('search')
+  @HttpCode(200)
+  @ApiOperation({ description: 'Search for keys in index' })
+  @ApiOkResponse({ type: GetKeysWithDetailsResponse })
+  @ApiRedisParams()
+  @ApiQueryRedisStringEncoding()
+  async search(
+    @Param('dbInstance') dbInstance: string,
+      @Body() dto: SearchRedisearchDto,
+  ): Promise<GetKeysWithDetailsResponse> {
+    return await this.service.search(
+      {
+        instanceId: dbInstance,
+      },
+      dto,
+    );
+  }
+}

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

@@ -0,0 +1,122 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import {
+  ArrayMinSize, IsDefined, IsEnum, IsInt, IsOptional, IsString, ValidateNested
+} from 'class-validator';
+import { Type } from 'class-transformer';
+import { RedisString } from 'src/common/constants';
+import { IsRedisString, RedisStringType } from 'src/common/decorators';
+
+export enum RedisearchIndexKeyType {
+  HASH = 'hash',
+  JSON = 'json',
+}
+
+export enum RedisearchIndexDataType {
+  TEXT = 'text',
+  TAG = 'tag',
+  NUMERIC = 'numeric',
+  GEO = 'geo',
+  VECTOR = 'vector',
+}
+
+export class ListRedisearchIndexesResponse {
+  @ApiProperty({
+    description: 'Indexes names',
+    type: String,
+  })
+  @RedisStringType({ each: true })
+  indexes: RedisString[];
+}
+
+export class CreateRedisearchIndexFieldDto {
+  @ApiProperty({
+    description: 'Name of field to be indexed',
+    type: String,
+  })
+  @IsDefined()
+  @RedisStringType()
+  @IsRedisString()
+  name: RedisString;
+
+  @ApiProperty({
+    description: 'Type of how data must be indexed',
+    enum: RedisearchIndexDataType,
+  })
+  @IsDefined()
+  @IsEnum(RedisearchIndexDataType)
+  type: RedisearchIndexDataType;
+}
+
+export class CreateRedisearchIndexDto {
+  @ApiProperty({
+    description: 'Index Name',
+    type: String,
+  })
+  @IsDefined()
+  @RedisStringType()
+  @IsRedisString()
+  index: RedisString;
+
+  @ApiProperty({
+    description: 'Type of keys to index',
+    enum: RedisearchIndexKeyType,
+  })
+  @IsDefined()
+  @IsEnum(RedisearchIndexKeyType)
+  type: RedisearchIndexKeyType;
+
+  @ApiPropertyOptional({
+    description: 'Keys prefixes to find keys for index',
+    isArray: true,
+    type: String,
+  })
+  @IsOptional()
+  @RedisStringType({ each: true })
+  @IsRedisString({ each: true })
+  prefixes?: RedisString[];
+
+  @ApiProperty({
+    description: 'Fields to index',
+    isArray: true,
+    type: CreateRedisearchIndexFieldDto,
+  })
+  @Type(() => CreateRedisearchIndexFieldDto)
+  @ValidateNested()
+  @ArrayMinSize(1)
+  fields: CreateRedisearchIndexFieldDto[];
+}
+
+export class SearchRedisearchDto {
+  @ApiProperty({
+    description: 'Index Name',
+    type: String,
+  })
+  @IsDefined()
+  @RedisStringType()
+  @IsRedisString()
+  index: RedisString;
+
+  @ApiProperty({
+    description: 'Query to search inside data fields',
+    type: String,
+  })
+  @IsDefined()
+  @IsString()
+  query: string;
+
+  @ApiProperty({
+    description: 'Limit number of results to be returned',
+    type: Number,
+  })
+  @IsDefined()
+  @IsInt()
+  limit: number = 500; // todo use @Default from another PR
+
+  @ApiProperty({
+    description: 'Offset position to start searching',
+    type: Number,
+  })
+  @IsDefined()
+  @IsInt()
+  offset: number = 0; // todo use @Default from another PR
+}