#RI-4813 - [BE] Do not duplicate Cloud databases

redisinsight/api/src/constants/custom-error-codes.ts

@@ -33,4 +33,7 @@ export enum CustomErrorCodes {
   CloudTaskNotFound = 11_112,
   CloudJobNotFound = 11_113,
   CloudSubscriptionAlreadyExistsFree = 11_114,
+
+  // General database errors [11200, 11299]
+  DatabaseAlreadyExists = 11_200,
 }

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

@@ -48,6 +48,7 @@ export default {
   REDIS_CLOUD_FORBIDDEN: 'Error fetching account details.',
 
   DATABASE_IS_INACTIVE: 'The database is inactive.',
+  DATABASE_ALREADY_EXISTS: 'The database already exists.',
 
   INCORRECT_CLUSTER_CURSOR_FORMAT: 'Incorrect cluster cursor format.',
   REMOVING_MULTIPLE_ELEMENTS_NOT_SUPPORT: () => 'Removing multiple elements is available for Redis databases v. 6.2 or later.',

redisinsight/api/src/modules/database-import/database-import.service.spec.ts

@@ -168,7 +168,7 @@ describe('DatabaseImportService', () => {
         ...pick(mockDatabase, ['host', 'port', 'name', 'connectionType', 'timeout', 'compressor', 'modules']),
         provider: 'RE_CLOUD',
         new: true,
-      });
+      }, false);
     });
     it('should create standalone with created name', async () => {
       await service['createDatabase']({
@@ -180,7 +180,7 @@ describe('DatabaseImportService', () => {
         ...pick(mockDatabase, ['host', 'port', 'name', 'connectionType', 'timeout', 'compressor', 'modules']),
         name: `${mockDatabase.host}:${mockDatabase.port}`,
         new: true,
-      });
+      }, false);
     });
     it('should create standalone with none compressor', async () => {
       await service['createDatabase']({
@@ -192,7 +192,7 @@ describe('DatabaseImportService', () => {
         ...pick(mockDatabase, ['host', 'port', 'name', 'connectionType', 'timeout', 'compressor', 'modules']),
         compressor: Compressor.NONE,
         new: true,
-      });
+      }, false);
     });
     it('should create standalone with compressor', async () => {
       await service['createDatabase']({
@@ -204,7 +204,7 @@ describe('DatabaseImportService', () => {
         ...pick(mockDatabase, ['host', 'port', 'name', 'connectionType', 'timeout', 'compressor', 'modules']),
         compressor: Compressor.GZIP,
         new: true,
-      });
+      }, false);
     });
     it('should create cluster database', async () => {
       await service['createDatabase']({
@@ -217,7 +217,7 @@ describe('DatabaseImportService', () => {
         ...pick(mockDatabase, ['host', 'port', 'name', 'timeout', 'compressor', 'modules']),
         connectionType: ConnectionType.CLUSTER,
         new: true,
-      });
+      }, false);
     });
   });
 

redisinsight/api/src/modules/database-import/database-import.service.ts

@@ -243,7 +243,7 @@ export class DatabaseImportService {
 
       const database = classToClass(Database, dto);
 
-      await this.databaseRepository.create(database);
+      await this.databaseRepository.create(database, false);
 
       return {
         index,

redisinsight/api/src/modules/database/database.controller.ts

@@ -98,7 +98,7 @@ export class DatabaseController {
   async create(
     @Body() dto: CreateDatabaseDto,
   ): Promise<Database> {
-    return await this.service.create(dto);
+    return await this.service.create(dto, true);
   }
 
   @UseInterceptors(ClassSerializerInterceptor)

redisinsight/api/src/modules/database/database.service.ts

@@ -96,15 +96,16 @@ export class DatabaseService {
   /**
    * Create new database with auto-detection of database type, modules, etc.
    * @param dto
+   * @param uniqueCheck
    */
-  async create(dto: CreateDatabaseDto): Promise<Database> {
+  async create(dto: CreateDatabaseDto, uniqueCheck = false): Promise<Database> {
     try {
       this.logger.log('Creating new database.');
 
       const database = await this.repository.create({
         ...await this.databaseFactory.createDatabaseModel(classToClass(Database, dto)),
         new: true,
-      });
+      }, uniqueCheck);
 
       // todo: clarify if we need this and if yes - rethink implementation
       try {

redisinsight/api/src/modules/database/exeptions/database-already-exists.exception.ts

@@ -0,0 +1,19 @@
+import { HttpException, HttpExceptionOptions, HttpStatus } from '@nestjs/common';
+import { CustomErrorCodes } from 'src/constants';
+import ERROR_MESSAGES from 'src/constants/error-messages';
+
+export class DatabaseAlreadyExistsException extends HttpException {
+  constructor(databaseId: string, message = ERROR_MESSAGES.DATABASE_ALREADY_EXISTS, options?: HttpExceptionOptions) {
+    const response = {
+      message,
+      statusCode: HttpStatus.CONFLICT,
+      error: 'DatabaseAlreadyExists',
+      errorCode: CustomErrorCodes.DatabaseAlreadyExists,
+      resource: {
+        databaseId,
+      },
+    };
+
+    super(response, response.statusCode, options);
+  }
+}

redisinsight/api/src/modules/database/exeptions/index.ts

@@ -0,0 +1 @@
+export * from './database-already-exists.exception';

redisinsight/api/src/modules/database/repositories/database.repository.ts

@@ -27,8 +27,9 @@ export abstract class DatabaseRepository {
   /**
    * Create database
    * @param database
+   * @param uniqueCheck
    */
-  abstract create(database: Database): Promise<Database>;
+  abstract create(database: Database, uniqueCheck: boolean): Promise<Database>;
 
   /**
    * Update database with new data

redisinsight/api/src/modules/database/repositories/local.database.repository.spec.ts

@@ -45,6 +45,8 @@ import { CaCertificateRepository } from 'src/modules/certificate/repositories/ca
 import { ClientCertificateRepository } from 'src/modules/certificate/repositories/client-certificate.repository';
 import { cloneClassInstance } from 'src/utils';
 import { SshOptionsEntity } from 'src/modules/ssh/entities/ssh-options.entity';
+import ERROR_MESSAGES from 'src/constants/error-messages';
+import { DatabaseAlreadyExistsException } from 'src/modules/database/exeptions';
 
 const listFields = [
   'id', 'name', 'host', 'port', 'db', 'timeout',
@@ -251,7 +253,7 @@ describe('LocalDatabaseRepository', () => {
 
   describe('create', () => {
     it('should create standalone database', async () => {
-      const result = await service.create(mockDatabase);
+      const result = await service.create(mockDatabase, false);
 
       expect(result).toEqual(mockDatabase);
       expect(caCertRepository.create).not.toHaveBeenCalled();
@@ -261,7 +263,7 @@ describe('LocalDatabaseRepository', () => {
     it('should create standalone database with cloud details', async () => {
       repository.save.mockResolvedValue(mockDatabaseEntityWithCloudDetails);
 
-      const result = await service.create(mockDatabaseWithCloudDetails);
+      const result = await service.create(mockDatabaseWithCloudDetails, false);
 
       expect(result).toEqual(mockDatabaseWithCloudDetails);
       expect(caCertRepository.create).not.toHaveBeenCalled();
@@ -271,7 +273,7 @@ describe('LocalDatabaseRepository', () => {
     it('should create standalone database (with existing certificates)', async () => {
       repository.save.mockResolvedValueOnce(mockDatabaseWithTlsAuthEntity);
 
-      const result = await service.create(mockDatabaseWithTlsAuth);
+      const result = await service.create(mockDatabaseWithTlsAuth, false);
 
       expect(result).toEqual(mockDatabaseWithTlsAuth);
       expect(caCertRepository.create).not.toHaveBeenCalled();
@@ -283,12 +285,26 @@ describe('LocalDatabaseRepository', () => {
 
       const result = await service.create(
         omit(cloneClassInstance(mockDatabaseWithTlsAuth), 'caCert.id', 'clientCert.id'),
+        false,
       );
 
       expect(result).toEqual(mockDatabaseWithTlsAuth);
       expect(caCertRepository.create).toHaveBeenCalled();
       expect(clientCertRepository.create).toHaveBeenCalled();
     });
+
+    it('should throw an error if create called with cloud details and have the same entity', async () => {
+      repository.findOneBy.mockResolvedValueOnce(mockDatabaseEntity);
+      try {
+        await service.create(mockDatabaseEntityWithCloudDetails, true);
+        fail();
+      } catch (e) {
+        expect(e).toBeInstanceOf(DatabaseAlreadyExistsException);
+        expect(e.message).toEqual(ERROR_MESSAGES.DATABASE_ALREADY_EXISTS);
+        expect(e.response?.resource?.databaseId).toEqual(mockDatabaseEntity.id);
+        expect(repository.save).not.toHaveBeenCalled();
+      }
+    });
   });
 
   describe('update', () => {

redisinsight/api/src/modules/database/repositories/local.database.repository.ts

@@ -1,7 +1,8 @@
 import { Injectable } from '@nestjs/common';
 import { DatabaseRepository } from 'src/modules/database/repositories/database.repository';
 import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
+import { FindOptionsWhere, Repository } from 'typeorm';
+import { get, set } from 'lodash';
 import { DatabaseEntity } from 'src/modules/database/entities/database.entity';
 import { Database } from 'src/modules/database/models/database';
 import { classToClass } from 'src/utils';
@@ -10,13 +11,24 @@ import { ModelEncryptor } from 'src/modules/encryption/model.encryptor';
 import { CaCertificateRepository } from 'src/modules/certificate/repositories/ca-certificate.repository';
 import { ClientCertificateRepository } from 'src/modules/certificate/repositories/client-certificate.repository';
 import { SshOptionsEntity } from 'src/modules/ssh/entities/ssh-options.entity';
+import { DatabaseAlreadyExistsException } from 'src/modules/database/exeptions';
 
 @Injectable()
 export class LocalDatabaseRepository extends DatabaseRepository {
   private readonly modelEncryptor: ModelEncryptor;
 
   private readonly sshModelEncryptor: ModelEncryptor;
 
+  private uniqFieldsForCloudDatabase: string[] = [
+    'host',
+    'port',
+    'username',
+    'password',
+    'caCert.certificate',
+    'clientCert.certificate',
+    'clientCert.key',
+  ];
+
   constructor(
     @InjectRepository(DatabaseEntity)
     private readonly repository: Repository<DatabaseEntity>,
@@ -88,8 +100,12 @@ export class LocalDatabaseRepository extends DatabaseRepository {
   /**
    * Create database with encrypted sensitive fields
    * @param database
+   * @param uniqueCheck
    */
-  public async create(database: Database): Promise<Database> {
+  public async create(database: Database, uniqueCheck: boolean): Promise<Database> {
+    if (uniqueCheck) {
+      await this.checkUniqueness(database);
+    }
     const entity = classToClass(DatabaseEntity, await this.populateCertificates(database));
     return classToClass(
       Database,
@@ -205,4 +221,39 @@ export class LocalDatabaseRepository extends DatabaseRepository {
 
     return decryptedEntity;
   }
+
+  /**
+   * Check uniqueness of the database
+   * @param database
+   * @private
+   * @throws DatabaseAlreadyExistsException
+   */
+  private async checkUniqueness(database: Database): Promise<void> {
+    // Do not create a connection if it triggered from cloud and have the same fields
+    if (database.cloudDetails?.cloudId) {
+      const entity = await this.encryptEntity(classToClass(DatabaseEntity, { ...database }));
+
+      if (entity.caCert) {
+        entity.caCert = await (new ModelEncryptor(this.encryptionService, [
+          'certificate',
+        ])).encryptEntity(entity.caCert);
+      }
+
+      if (entity.clientCert) {
+        entity.clientCert = await (new ModelEncryptor(this.encryptionService, [
+          'certificate', 'key',
+        ])).encryptEntity(entity.clientCert);
+      }
+
+      const query: FindOptionsWhere<DatabaseEntity> = {};
+      this.uniqFieldsForCloudDatabase.forEach((field) => {
+        set(query, field, get(entity, field));
+      });
+
+      const existingDatabase = await this.repository.findOneBy(query);
+      if (existingDatabase) {
+        throw new DatabaseAlreadyExistsException(existingDatabase.id);
+      }
+    }
+  }
 }

redisinsight/api/src/modules/database/repositories/stack.databases.repository.ts

@@ -82,7 +82,7 @@ export class StackDatabasesRepository extends LocalDatabaseRepository implements
           verifyServerCert: false,
           connectionType: ConnectionType.STANDALONE,
           lastConnection: null,
-        });
+        }, false);
       }
       this.logger.log(`Succeed to set predefined database ${id}`);
     } catch (error) {

redisinsight/api/src/modules/encryption/model.encryptor.ts

@@ -23,6 +23,7 @@ export class ModelEncryptor {
   async encryptEntity<T>(entity: T): Promise<T> {
     const encryptedEntity = cloneClassInstance(entity);
 
+    // TODO: implement support depth in field, 'obj.field'
     await Promise.all(this.fields.map(async (field) => {
       if (entity[field]) {
         const { data, encryption } = await this.encryptionService.encrypt(entity[field]);