RI-6336 Allow to hide show columns in browser

redisinsight/api/src/modules/browser/keys/dto/get.keys-info.dto.ts

@@ -4,7 +4,15 @@ import { IsRedisString, RedisStringType } from 'src/common/decorators';
 import { RedisString } from 'src/common/constants';
 import { KeyDto, RedisDataType } from './key.dto';
 
-export class GetKeyInfoDto extends KeyDto {}
+export class GetKeyInfoDto extends KeyDto {
+  @ApiPropertyOptional({
+    description: 'Flag to determine if size should be requested and shown in the response',
+    type: Boolean,
+    default: false,
+  })
+  @IsOptional()
+  includeSize?: boolean;
+}
 
 export class GetKeysInfoDto {
   @ApiProperty({
@@ -31,4 +39,20 @@ export class GetKeysInfoDto {
   })
   @IsOptional()
   type?: RedisDataType;
-}
+
+  @ApiPropertyOptional({
+    description: 'Flag to determine if keys should be requested and shown in the response',
+    type: Boolean,
+    default: true,
+  })
+  @IsOptional()
+  includeSize?: boolean;
+
+  @ApiPropertyOptional({
+    description: 'Flag to determine if TTL should be requested and shown in the response',
+    type: Boolean,
+    default: true,
+  })
+  @IsOptional()
+  includeTTL?: boolean;
+}

redisinsight/api/src/modules/browser/keys/key-info/strategies/hash.key-info.strategy.spec.ts

@@ -34,52 +34,120 @@ describe('HashKeyInfoStrategy', () => {
 
   describe('getInfo', () => {
     const key = getKeyInfoResponse.name;
-    it('should return appropriate value', async () => {
-      when(mockStandaloneRedisClient.sendPipeline)
-        .calledWith([
-          [BrowserToolKeysCommands.Ttl, key],
-          [BrowserToolKeysCommands.MemoryUsage, key, 'samples', '0'],
-          [BrowserToolHashCommands.HLen, key],
-        ])
-        .mockResolvedValue([
-          [null, -1],
-          [null, 50],
-          [null, 10],
-        ]);
-
-      const result = await strategy.getInfo(
-        mockStandaloneRedisClient,
-        key,
-        RedisDataType.Hash,
-      );
-
-      expect(result).toEqual(getKeyInfoResponse);
+
+    describe('when includeSize is true', () => {
+      it('should return all info in single pipeline', async () => {
+        when(mockStandaloneRedisClient.sendPipeline)
+          .calledWith([
+            [BrowserToolKeysCommands.Ttl, key],
+            [BrowserToolHashCommands.HLen, key],
+            [BrowserToolKeysCommands.MemoryUsage, key, 'samples', '0'],
+          ])
+          .mockResolvedValueOnce([
+            [null, -1],
+            [null, 10],
+            [null, 50],
+          ]);
+
+        const result = await strategy.getInfo(
+          mockStandaloneRedisClient,
+          key,
+          RedisDataType.Hash,
+          true,
+        );
+
+        expect(result).toEqual(getKeyInfoResponse);
+      });
     });
-    it('should return size with null value', async () => {
-      const replyError: ReplyError = {
-        name: 'ReplyError',
-        command: BrowserToolKeysCommands.MemoryUsage,
-        message: "ERR unknown command 'memory'",
-      };
-      when(mockStandaloneRedisClient.sendPipeline)
-        .calledWith([
-          [BrowserToolKeysCommands.Ttl, key],
-          [BrowserToolKeysCommands.MemoryUsage, key, 'samples', '0'],
-          [BrowserToolHashCommands.HLen, key],
-        ])
-        .mockResolvedValue([
-          [null, -1],
-          [replyError, null],
-          [null, 10],
-        ]);
-
-      const result = await strategy.getInfo(
-        mockStandaloneRedisClient,
-        key,
-        RedisDataType.Hash,
-      );
-
-      expect(result).toEqual({ ...getKeyInfoResponse, size: null });
+
+    describe('when includeSize is false', () => {
+      it('should return appropriate value', async () => {
+        when(mockStandaloneRedisClient.sendPipeline)
+          .calledWith([
+            [BrowserToolKeysCommands.Ttl, key],
+            [BrowserToolHashCommands.HLen, key],
+          ])
+          .mockResolvedValueOnce([
+            [null, -1],
+            [null, 10],
+          ]);
+
+        when(mockStandaloneRedisClient.sendPipeline)
+          .calledWith([
+            [BrowserToolKeysCommands.MemoryUsage, key, 'samples', '0'],
+          ])
+          .mockResolvedValueOnce([
+            [null, 50],
+          ]);
+
+        const result = await strategy.getInfo(
+          mockStandaloneRedisClient,
+          key,
+          RedisDataType.Hash,
+          false,
+        );
+
+        expect(result).toEqual(getKeyInfoResponse);
+      });
+
+      it('should return size with null value when memory usage fails', async () => {
+        const replyError: ReplyError = {
+          name: 'ReplyError',
+          command: BrowserToolKeysCommands.MemoryUsage,
+          message: "ERR unknown command 'memory'",
+        };
+        when(mockStandaloneRedisClient.sendPipeline)
+          .calledWith([
+            [BrowserToolKeysCommands.Ttl, key],
+            [BrowserToolHashCommands.HLen, key],
+          ])
+          .mockResolvedValueOnce([
+            [null, -1],
+            [null, 10],
+          ]);
+
+        when(mockStandaloneRedisClient.sendPipeline)
+          .calledWith([
+            [BrowserToolKeysCommands.MemoryUsage, key, 'samples', '0'],
+          ])
+          .mockResolvedValueOnce([
+            [replyError, null],
+          ]);
+
+        const result = await strategy.getInfo(
+          mockStandaloneRedisClient,
+          key,
+          RedisDataType.Hash,
+          false,
+        );
+
+        expect(result).toEqual({ ...getKeyInfoResponse, size: null });
+      });
+
+      it('should not check size when length >= 50,000', async () => {
+        when(mockStandaloneRedisClient.sendPipeline)
+          .calledWith([
+            [BrowserToolKeysCommands.Ttl, key],
+            [BrowserToolHashCommands.HLen, key],
+          ])
+          .mockResolvedValueOnce([
+            [null, -1],
+            [null, 50000],
+          ]);
+
+        const result = await strategy.getInfo(
+          mockStandaloneRedisClient,
+          key,
+          RedisDataType.Hash,
+          false,
+        );
+
+        expect(result).toEqual({
+          ...getKeyInfoResponse,
+          length: 50000,
+          size: -1
+        });
+      });
     });
   });
 });

redisinsight/api/src/modules/browser/keys/key-info/strategies/hash.key-info.strategy.ts

@@ -12,25 +12,53 @@ export class HashKeyInfoStrategy extends KeyInfoStrategy {
     client: RedisClient,
     key: RedisString,
     type: string,
+    includeSize: boolean,
   ): Promise<GetKeyInfoResponse> {
     this.logger.debug(`Getting ${RedisDataType.Hash} type info.`);
 
+    if (includeSize !== false) {
+      const [
+        [, ttl = null],
+        [, length = null],
+        [, size = null],
+      ] = await client.sendPipeline([
+        [BrowserToolKeysCommands.Ttl, key],
+        [BrowserToolHashCommands.HLen, key],
+        [BrowserToolKeysCommands.MemoryUsage, key, 'samples', '0'],
+      ]) as [any, number][];
+
+      return {
+        name: key,
+        type,
+        ttl,
+        size,
+        length,
+      };
+    }
+
     const [
       [, ttl = null],
-      [, size = null],
       [, length = null],
     ] = await client.sendPipeline([
       [BrowserToolKeysCommands.Ttl, key],
-      [BrowserToolKeysCommands.MemoryUsage, key, 'samples', '0'],
       [BrowserToolHashCommands.HLen, key],
     ]) as [any, number][];
 
+    let size = -1;
+    if (length < 50_000) {
+      const sizeData = await client.sendPipeline([
+        [BrowserToolKeysCommands.MemoryUsage, key, 'samples', '0'],
+      ]) as [any, number][];
+      size = sizeData && sizeData[0] && sizeData[0][1];
+    }
+
     return {
       name: key,
       type,
       ttl,
       size,
       length,
     };
+
   }
 }

redisinsight/api/src/modules/browser/keys/key-info/strategies/key-info.strategy.ts

@@ -11,5 +11,6 @@ export abstract class KeyInfoStrategy {
     client: RedisClient,
     key: RedisString,
     type: string,
+    includeSize: boolean,
   ): Promise<GetKeyInfoResponse>;
 }