Merge branch 'main' of https://github.com/RedisInsight/RedisInsight into feature/RI-3527_lua_scripts

Author: AmirAllayarovSofteq

redisinsight/api/package.json

@@ -27,7 +27,7 @@
     "start:prod": "cross-env NODE_ENV=production node dist/src/main",
     "test": "cross-env NODE_ENV=test ./node_modules/.bin/jest -w 1",
     "test:watch": "cross-env NODE_ENV=test jest --watch -w 1",
-    "test:cov": "cross-env NODE_ENV=test ./node_modules/.bin/jest --coverage -w 1",
+    "test:cov": "cross-env NODE_ENV=test ./node_modules/.bin/jest --forceExit --coverage -w 1",
     "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand -w 1",
     "test:e2e": "jest --config ./test/jest-e2e.json -w 1",
     "typeorm": "ts-node -r tsconfig-paths/register ./node_modules/typeorm/cli.js -d ./config/ormconfig.ts",

redisinsight/api/src/__mocks__/index.ts

@@ -17,3 +17,4 @@ export * from './server';
 export * from './redis-enterprise';
 export * from './redis-sentinel';
 export * from './database-import';
+export * from './redis-client';

redisinsight/api/src/__mocks__/redis-client.ts

@@ -0,0 +1,18 @@
+import { IRedisClientInstance, RedisService } from 'src/modules/redis/redis.service';
+import { mockCommonClientMetadata } from 'src/__mocks__/common';
+import { mockIORedisClient } from 'src/__mocks__/redis';
+import { ClientMetadata } from 'src/common/models';
+
+export const mockRedisClientInstance: IRedisClientInstance = {
+  id: RedisService.generateId(mockCommonClientMetadata),
+  clientMetadata: mockCommonClientMetadata,
+  client: mockIORedisClient,
+  lastTimeUsed: 1619791508019,
+};
+
+export const generateMockRedisClientInstance = (clientMetadata: Partial<ClientMetadata>): IRedisClientInstance => ({
+  id: RedisService.generateId(clientMetadata as ClientMetadata),
+  clientMetadata: clientMetadata as ClientMetadata,
+  client: mockIORedisClient,
+  lastTimeUsed: Date.now(),
+});

redisinsight/api/src/__mocks__/redis.ts

@@ -68,11 +68,18 @@ export const mockRedisService = jest.fn(() => ({
   getClientInstance: jest.fn().mockResolvedValue({
     client: mockIORedisClient,
   }),
-  setClientInstance: jest.fn(),
+  setClientInstance: jest.fn().mockReturnValue({
+    client: mockIORedisClient,
+  }),
   isClientConnected: jest.fn().mockReturnValue(true),
-  connectToDatabaseInstance: jest.fn().mockResolvedValue(mockIORedisClient),
-  createStandaloneClient: jest.fn().mockResolvedValue(mockIORedisClient),
-  createSentinelClient: jest.fn().mockResolvedValue(mockIORedisSentinel),
-  createClusterClient: jest.fn().mockResolvedValue(mockIORedisCluster),
   removeClientInstance: jest.fn(),
+  removeClientInstances: jest.fn(),
+  findClientInstances: jest.fn(),
+}));
+
+export const mockRedisConnectionFactory = jest.fn(() => ({
+  createRedisConnection: jest.fn().mockResolvedValue(mockIORedisClient),
+  createStandaloneConnection: jest.fn().mockResolvedValue(mockIORedisClient),
+  createSentinelConnection: jest.fn().mockResolvedValue(mockIORedisSentinel),
+  createClusterConnection: jest.fn().mockResolvedValue(mockIORedisCluster),
 }));

redisinsight/api/src/common/constants/api.ts

@@ -1,2 +1,3 @@
 export const API_PARAM_DATABASE_ID = 'dbInstance';
+export const API_HEADER_DATABASE_INDEX = 'ri-db-index';
 export const API_PARAM_CLI_CLIENT_ID = 'uuid';

redisinsight/api/src/common/decorators/client-metadata/client-metadata.decorator.ts

@@ -3,43 +3,40 @@ import { plainToClass } from 'class-transformer';
 import { ClientContext, ClientMetadata } from 'src/common/models';
 import { sessionFromRequestFactory } from 'src/common/decorators';
 import { Validator } from 'class-validator';
-import { API_PARAM_DATABASE_ID } from 'src/common/constants';
+import { API_HEADER_DATABASE_INDEX, API_PARAM_DATABASE_ID } from 'src/common/constants';
+import { ApiHeader, ApiParam } from '@nestjs/swagger';
 
 const validator = new Validator();
 
 export interface IClientMetadataParamOptions {
   databaseIdParam?: string,
   uniqueIdParam?: string,
   context?: ClientContext,
+  ignoreDbIndex?: boolean,
 }
 
 export const clientMetadataParamFactory = (
   options: IClientMetadataParamOptions,
   ctx: ExecutionContext,
 ): ClientMetadata => {
-  const opts: IClientMetadataParamOptions = {
-    context: ClientContext.Common,
-    databaseIdParam: API_PARAM_DATABASE_ID,
-    ...options,
-  };
-
   const req = ctx.switchToHttp().getRequest();
 
   let databaseId;
-  if (opts?.databaseIdParam) {
-    databaseId = req.params?.[opts.databaseIdParam];
+  if (options?.databaseIdParam) {
+    databaseId = req.params?.[options.databaseIdParam];
   }
 
   let uniqueId;
-  if (opts?.uniqueIdParam) {
-    uniqueId = req.params?.[opts.uniqueIdParam];
+  if (options?.uniqueIdParam) {
+    uniqueId = req.params?.[options.uniqueIdParam];
   }
 
   const clientMetadata = plainToClass(ClientMetadata, {
     session: sessionFromRequestFactory(undefined, ctx),
     databaseId,
     uniqueId,
-    context: opts?.context || ClientContext.Common,
+    context: options?.context || ClientContext.Common,
+    db: options?.ignoreDbIndex ? undefined : req?.headers?.[API_HEADER_DATABASE_INDEX],
   });
 
   const errors = validator.validateSync(clientMetadata, {
@@ -53,4 +50,35 @@ export const clientMetadataParamFactory = (
   return clientMetadata;
 };
 
-export const ClientMetadataParam = createParamDecorator(clientMetadataParamFactory);
+export const ClientMetadataParam = (
+  options?: IClientMetadataParamOptions,
+) => {
+  const opts: IClientMetadataParamOptions = {
+    context: ClientContext.Common,
+    databaseIdParam: API_PARAM_DATABASE_ID,
+    ignoreDbIndex: false,
+    ...options,
+  };
+
+  return createParamDecorator(clientMetadataParamFactory, [
+    (target: any, key: string) => {
+      // Here it is. Use the `@ApiQuery` decorator purely as a function to define the meta only once here.
+      ApiParam({
+        name: opts.databaseIdParam,
+        schema: { type: 'string' },
+        required: true,
+      })(target, key, Object.getOwnPropertyDescriptor(target, key));
+      if (!opts.ignoreDbIndex) {
+        ApiHeader({
+          name: API_HEADER_DATABASE_INDEX,
+          schema: {
+            default: undefined,
+            type: 'number',
+            minimum: 0,
+          },
+          required: false,
+        })(target, key, Object.getOwnPropertyDescriptor(target, key));
+      }
+    },
+  ])(opts);
+};

redisinsight/api/src/common/models/client-metadata.ts

@@ -1,7 +1,7 @@
 import { Session } from 'src/common/models/session';
 import { Type } from 'class-transformer';
 import {
-  IsEnum, IsNotEmpty, IsOptional, IsString,
+  IsEnum, IsNotEmpty, IsNumber, IsOptional, IsString, Max, Min,
 } from 'class-validator';
 
 export enum ClientContext {
@@ -27,4 +27,11 @@ export class ClientMetadata {
   @IsOptional()
   @IsString()
   uniqueId?: string;
+
+  @IsOptional()
+  @IsNumber()
+  @Type(() => Number)
+  @Min(0)
+  @Max(2147483647)
+  db?: number;
 }

redisinsight/api/src/common/models/database-index.ts

@@ -0,0 +1,4 @@
+import { PickType } from '@nestjs/swagger';
+import { ClientMetadata } from 'src/common/models/client-metadata';
+
+export class DatabaseIndex extends PickType(ClientMetadata, ['db'] as const) {}

redisinsight/api/src/common/models/index.ts

@@ -2,3 +2,4 @@ export * from './common';
 export * from './endpoint';
 export * from './session';
 export * from './client-metadata';
+export * from './database-index';

redisinsight/api/src/common/pipes/database-index.validation.pipe.ts

@@ -0,0 +1,7 @@
+import { ArgumentMetadata, ValidationPipe } from '@nestjs/common';
+
+export class DbIndexValidationPipe extends ValidationPipe {
+  async transform(db, metadata: ArgumentMetadata) {
+    return super.transform({ db }, metadata);
+  }
+}