Merge pull request #2605 from RedisInsight/feature/RI-4813_not_duplicate_cloud_database

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

Author: mariasergeenko

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', () => {