Feature/ri 6881 disable db management (#4428)

* RI-6881 initial implementation (API)

* RI-6881 rename RI_READONLY_CONNECTIONS to RI_DATABASE_MANAGEMENT to avoid misunderstandings

* RI-6881 fix guard behavior

* RI-6881 remove console.log

* RI-6881 add tests

* RI-6881 fix ITests

* RI-6881 fix cloud jobs conditions

* RI-6881 hide db CRUD buttons (except cloud) (#4429)

* RI-6881 hide db CRUD buttons (except cloud)

* RI-6881 add custom error handler + analytics

Author: ArtemHoruzhenko

redisinsight/api/config/default.ts

@@ -88,6 +88,7 @@ export default {
     requestTimeout: parseInt(process.env.RI_REQUEST_TIMEOUT, 10) || 25000,
     excludeRoutes: [],
     excludeAuthRoutes: [],
+    databaseManagement: process.env.RI_DATABASE_MANAGEMENT !== 'false',
   },
   statics: {
     initDefaults: process.env.RI_STATICS_INIT_DEFAULTS ? process.env.RI_STATICS_INIT_DEFAULTS === 'true' : true,

redisinsight/api/src/__mocks__/database-import.ts

@@ -95,3 +95,7 @@ export const mockSshImportService = jest.fn(() => ({
     id: undefined,
   }),
 }));
+
+export const mockDatabaseImportService = jest.fn(() => ({
+  import: jest.fn(),
+}));

redisinsight/api/src/__mocks__/databases.ts

@@ -18,6 +18,7 @@ import { CloudDatabaseDetailsEntity } from 'src/modules/cloud/database/entities/
 import { mockCloudDatabaseDetails, mockCloudDatabaseDetailsEntity } from 'src/__mocks__/cloud-database';
 import { mockRedisClientListResult } from 'src/__mocks__/database-info';
 import { DatabaseOverviewKeyspace } from 'src/modules/database/constants/overview';
+import { CreateDatabaseDto } from 'src/modules/database/dto/create.database.dto';
 
 export const mockDatabaseId = 'a77b23c1-7816-4ea4-b61f-d37795a0f805-db-id';
 
@@ -43,6 +44,12 @@ export const mockDatabase = Object.assign(new Database(), {
   version: '7.0',
 });
 
+export const mockCreateDatabaseDto = Object.assign(new CreateDatabaseDto(), {
+  name: mockDatabase.name,
+  host: mockDatabase.host,
+  port: mockDatabase.port,
+});
+
 export const mockDatabaseModules = [
   {
     name: 'rg',
@@ -267,6 +274,11 @@ export const mockDatabaseRepository = jest.fn(() => ({
 export const mockDatabaseService = jest.fn(() => ({
   get: jest.fn().mockResolvedValue(mockDatabase),
   create: jest.fn().mockResolvedValue(mockDatabase),
+  update: jest.fn().mockResolvedValue(mockDatabase),
+  clone: jest.fn().mockResolvedValue(mockDatabase),
+  testConnection: jest.fn().mockResolvedValue(undefined),
+  delete: jest.fn().mockResolvedValue(undefined),
+  bulkDelete: jest.fn().mockResolvedValue({ affected: 0 }),
   list: jest.fn(),
 }));
 

redisinsight/api/src/__mocks__/feature.ts

@@ -184,6 +184,11 @@ export const mockFeatureSso = Object.assign(new Feature(), {
   },
 });
 
+export const mockFeatureDatabaseManagement = Object.assign(new Feature(), {
+  name: KnownFeatures.DatabaseManagement,
+  flag: true,
+});
+
 export const mockFeatureRedisClient = Object.assign(new Feature(), {
   name: KnownFeatures.RedisClient,
   flag: true,

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

@@ -1,5 +1,6 @@
 import { RedisEnterpriseDatabase } from 'src/modules/redis-enterprise/dto/cluster.dto';
 import { RedisEnterpriseDatabaseStatus } from 'src/modules/redis-enterprise/models/redis-enterprise-database';
+import { AddRedisEnterpriseDatabasesDto } from 'src/modules/redis-enterprise/dto/redis-enterprise-cluster.dto';
 
 export const mockRedisEnterpriseDatabaseDto: RedisEnterpriseDatabase = {
   uid: 1,
@@ -14,7 +15,19 @@ export const mockRedisEnterpriseDatabaseDto: RedisEnterpriseDatabase = {
   password: null,
 };
 
+export const mockAddRedisEnterpriseDatabasesDto = Object.assign(new AddRedisEnterpriseDatabasesDto(), {
+  host: 'localhost',
+  port: 9443,
+  username: 'admin',
+  password: 'password',
+  uids: [1],
+});
+
 export const mockRedisEnterpriseAnalytics = jest.fn(() => ({
   sendGetREClusterDbsSucceedEvent: jest.fn(),
   sendGetREClusterDbsFailedEvent: jest.fn(),
 }));
+
+export const mockRedisEnterpriseService = jest.fn(() => ({
+  addRedisEnterpriseDatabases: jest.fn().mockResolvedValue([]),
+}));

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

@@ -1,5 +1,6 @@
 import { SentinelMaster, SentinelMasterStatus } from 'src/modules/redis-sentinel/models/sentinel-master';
 import { Endpoint } from 'src/common/models';
+import { CreateSentinelDatabasesDto } from 'src/modules/redis-sentinel/dto/create.sentinel.databases.dto';
 
 export const mockOtherSentinelsReply = [[
   'ip',
@@ -27,7 +28,22 @@ export const mockSentinelMasterDto: SentinelMaster = {
   nodes: [mockOtherSentinelEndpoint],
 };
 
+export const mockCreateSentinelDatabasesDto = Object.assign(new CreateSentinelDatabasesDto(), {
+  ...mockOtherSentinelEndpoint,
+  masters: [
+    {
+      name: mockSentinelMasterDto.name,
+      alias: mockSentinelMasterDto.name,
+    },
+  ],
+});
+
 export const mockRedisSentinelAnalytics = jest.fn(() => ({
   sendGetSentinelMastersSucceedEvent: jest.fn(),
   sendGetSentinelMastersFailedEvent: jest.fn(),
 }));
+
+export const mockRedisSentinelService = jest.fn(() => ({
+  getSentinelMasters: jest.fn().mockResolvedValue([mockSentinelMasterDto]),
+  createSentinelDatabases: jest.fn().mockResolvedValue([]),
+}));

redisinsight/api/src/common/decorators/database-management.decorator.ts

@@ -0,0 +1,8 @@
+import { applyDecorators, UseGuards } from '@nestjs/common';
+import { DatabaseManagementGuard } from 'src/common/guards/database-management.guard';
+
+export function DatabaseManagement() {
+  return applyDecorators(
+    UseGuards(new DatabaseManagementGuard()),
+  );
+}

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

@@ -8,3 +8,4 @@ export * from './object-as-map.decorator';
 export * from './is-multi-number.decorator';
 export * from './is-bigger-than.decorator';
 export * from './is-github-link.decorator';
+export * from './database-management.decorator';

redisinsight/api/src/common/guards/database-management.guard.spec.ts

@@ -0,0 +1,36 @@
+import { when } from 'jest-when';
+import { DatabaseManagementGuard } from 'src/common/guards/database-management.guard';
+import { ForbiddenException } from '@nestjs/common';
+import config, { Config } from 'src/utils/config';
+
+const mockServerConfig = config.get('server') as Config['server'];
+
+jest.mock('src/utils/config', jest.fn(
+  () => jest.requireActual('src/utils/config') as object,
+));
+
+describe('DatabaseManagementGuard', () => {
+  let guard: DatabaseManagementGuard;
+  let configGetSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    configGetSpy = jest.spyOn(config, 'get');
+
+    when(configGetSpy).calledWith('server').mockReturnValue(mockServerConfig);
+
+    guard = new DatabaseManagementGuard();
+  });
+
+  it('should return true', () => {
+    mockServerConfig.databaseManagement = true;
+
+    expect(guard.canActivate()).toEqual(true);
+  });
+
+  it('should throw an error when database management is disabled', () => {
+    mockServerConfig.databaseManagement = false;
+
+    expect(guard.canActivate).toThrowError(new ForbiddenException('Database connection management is disabled.'));
+  });
+});

redisinsight/api/src/common/guards/database-management.guard.ts

@@ -0,0 +1,16 @@
+import { CanActivate, ForbiddenException, Injectable } from '@nestjs/common';
+import config, { Config } from 'src/utils/config';
+import ERROR_MESSAGES from 'src/constants/error-messages';
+
+const SERVER_CONFIG = config.get('server') as Config['server'];
+
+@Injectable()
+export class DatabaseManagementGuard implements CanActivate {
+  canActivate(): boolean {
+    if (!SERVER_CONFIG.databaseManagement) {
+      throw new ForbiddenException(ERROR_MESSAGES.DATABASE_MANAGEMENT_IS_DISABLED);
+    }
+
+    return true;
+  }
+}