#RI-3972 - resolve comments

Author: AmirAllayarovSofteq

redisinsight/api/src/constants/redis-modules.ts

@@ -8,20 +8,6 @@ export enum AdditionalRedisModuleName {
   RedisTimeSeries = 'timeseries',
 }
 
-enum RediSearchModuleName {
-  Search = 'search',
-  SearchLight = 'searchlight',
-  FT = 'ft',
-  FTL = 'ftl',
-}
-
-export const REDISEARCH_MODULES = [
-  RediSearchModuleName.Search,
-  RediSearchModuleName.SearchLight,
-  RediSearchModuleName.FT,
-  RediSearchModuleName.FTL,
-];
-
 export const SUPPORTED_REDIS_MODULES = Object.freeze({
   ai: AdditionalRedisModuleName.RedisAI,
   graph: AdditionalRedisModuleName.RedisGraph,

redisinsight/api/src/modules/recommendation/providers/recommendation.provider.spec.ts

@@ -34,27 +34,6 @@ const mockRedisAclListResponse_2: string[] = [
   'user test_2 on nopass ~* &* +@all',
 ];
 
-const mockRedisModulesResponse_1 = [
-  { name: 'ai', ver: 10000 },
-  { name: 'graph', ver: 10000 },
-  { name: 'rg', ver: 10000 },
-  { name: 'bf', ver: 10000 },
-  { name: 'ReJSON', ver: 10000 },
-  { name: 'search', ver: 10000 },
-  { name: 'timeseries', ver: 10000 },
-  { name: 'customModule', ver: 10000 },
-].map((item) => ([].concat(...Object.entries(item))));
-
-const mockRedisModulesResponse_2 = [
-  { name: 'ai', ver: 10000 },
-  { name: 'graph', ver: 10000 },
-  { name: 'rg', ver: 10000 },
-  { name: 'bf', ver: 10000 },
-  { name: 'ReJSON', ver: 10000 },
-  { name: 'timeseries', ver: 10000 },
-  { name: 'customModule', ver: 10000 },
-].map((item) => ([].concat(...Object.entries(item))));
-
 const mockFTListResponse_1 = [];
 const mockFTListResponse_2 = ['idx'];
 
@@ -566,25 +545,7 @@ describe('RecommendationProvider', () => {
   });
 
   describe('determineRediSearchRecommendation', () => {
-    it('should not return rediSearch recommendation when rediSearch module was download with indexes', async () => {
-      when(nodeClient.sendCommand)
-        .calledWith(jasmine.objectContaining({ name: 'module' }))
-        .mockResolvedValue(mockRedisModulesResponse_1);
-
-      when(nodeClient.sendCommand)
-        .calledWith(jasmine.objectContaining({ name: 'FT._LIST' }))
-        .mockResolvedValue(mockFTListResponse_2);
-
-      const redisServerRecommendation = await service
-        .determineRediSearchRecommendation(nodeClient, [mockJSONKey]);
-      expect(redisServerRecommendation).toEqual(null);
-    });
-
     it('should return rediSearch recommendation when there is JSON key', async () => {
-      when(nodeClient.sendCommand)
-        .calledWith(jasmine.objectContaining({ name: 'module' }))
-        .mockResolvedValue(mockRedisModulesResponse_1);
-
       when(nodeClient.sendCommand)
         .calledWith(jasmine.objectContaining({ name: 'FT._LIST' }))
         .mockResolvedValue(mockFTListResponse_1);
@@ -595,10 +556,6 @@ describe('RecommendationProvider', () => {
     });
 
     it('should return rediSearch recommendation when there is huge string key', async () => {
-      when(nodeClient.sendCommand)
-        .calledWith(jasmine.objectContaining({ name: 'module' }))
-        .mockResolvedValue(mockRedisModulesResponse_1);
-
       when(nodeClient.sendCommand)
         .calledWith(jasmine.objectContaining({ name: 'FT._LIST' }))
         .mockResolvedValue(mockFTListResponse_1);
@@ -609,10 +566,6 @@ describe('RecommendationProvider', () => {
     });
 
     it('should not return rediSearch recommendation when there is small string key', async () => {
-      when(nodeClient.sendCommand)
-        .calledWith(jasmine.objectContaining({ name: 'module' }))
-        .mockResolvedValue(mockRedisModulesResponse_1);
-
       when(nodeClient.sendCommand)
         .calledWith(jasmine.objectContaining({ name: 'FT._LIST' }))
         .mockResolvedValue(mockFTListResponse_1);
@@ -622,31 +575,33 @@ describe('RecommendationProvider', () => {
       expect(redisServerRecommendation).toEqual(null);
     });
 
-    it('should not return rediSearch recommendation when ft command execute with error', async () => {
-      when(nodeClient.sendCommand)
-        .calledWith(jasmine.objectContaining({ name: 'module' }))
-        .mockResolvedValue(mockRedisModulesResponse_1);
-
+    it('should not return rediSearch recommendation when there are no indexes', async () => {
       when(nodeClient.sendCommand)
         .calledWith(jasmine.objectContaining({ name: 'FT._LIST' }))
-        .mockRejectedValue("some error");
+        .mockResolvedValue(mockFTListResponse_2);
 
       const redisServerRecommendation = await service
         .determineRediSearchRecommendation(nodeClient, [mockJSONKey]);
       expect(redisServerRecommendation).toEqual(null);
     });
 
-    it('should not return rediSearch recommendation when module command execute with error', async () => {
+    it('should ignore errors when ft command execute with error', async () => {
       when(nodeClient.sendCommand)
-        .calledWith(jasmine.objectContaining({ name: 'module' }))
-        .mockResolvedValue("some error");
+        .calledWith(jasmine.objectContaining({ name: 'FT._LIST' }))
+        .mockRejectedValue("some error");
+
+      const redisServerRecommendation = await service
+        .determineRediSearchRecommendation(nodeClient, [mockJSONKey]);
+      expect(redisServerRecommendation).toEqual({ name: RECOMMENDATION_NAMES.REDIS_SEARCH });
+    });
 
+    it('should ignore errors when ft command execute with error', async () => {
       when(nodeClient.sendCommand)
         .calledWith(jasmine.objectContaining({ name: 'FT._LIST' }))
-        .mockResolvedValue(mockFTListResponse_1);
+        .mockRejectedValue("some error");
 
       const redisServerRecommendation = await service
-        .determineRediSearchRecommendation(nodeClient, [mockJSONKey]);
+        .determineRediSearchRecommendation(nodeClient, [mockRediSearchStringKey_2]);
       expect(redisServerRecommendation).toEqual(null);
     });
   });

redisinsight/api/src/modules/recommendation/providers/recommendation.provider.ts

@@ -3,7 +3,7 @@ import { Redis, Cluster, Command } from 'ioredis';
 import { get } from 'lodash';
 import * as semverCompare from 'node-version-compare';
 import { convertRedisInfoReplyToObject, convertBulkStringsToObject, convertStringsArrayToObject } from 'src/utils';
-import { RECOMMENDATION_NAMES, IS_TIMESTAMP, REDISEARCH_MODULES } from 'src/constants';
+import { RECOMMENDATION_NAMES, IS_TIMESTAMP } from 'src/constants';
 import { RedisDataType } from 'src/modules/browser/dto';
 import { Recommendation } from 'src/modules/database-analysis/models/recommendation';
 import { Key } from 'src/modules/database-analysis/models';
@@ -338,20 +338,15 @@ export class RecommendationProvider {
     keys: Key[],
   ): Promise<Recommendation> {
     try {
-      const reply = await redisClient.sendCommand(
-        new Command('module', ['list'], { replyEncoding: 'utf8' }),
-      ) as any[];
-      const modules = reply.map((module: any[]) => convertStringsArrayToObject(module));
-      const isRediSearchModule = modules.some(({ name }) => REDISEARCH_MODULES
-        .some((search: string) => name === search));
-
-      if (isRediSearchModule) {
+      try {
         const indexes = await redisClient.sendCommand(
           new Command('FT._LIST', [], { replyEncoding: 'utf8' }),
         ) as any[];
         if (indexes.length) {
           return null;
         }
+      } catch (err) {
+        // Ignore errors
       }
 
       const isBigStringOrJSON = keys.some((key) => (