update CORS methods and remove unused error class; enhance key enrollment logic

Author: flopez7

packages/apps/human-app/server/src/main.ts

@@ -19,7 +19,7 @@ async function bootstrap() {
   if (envConfigService.isCorsEnabled) {
     app.enableCors({
       origin: envConfigService.corsEnabledOrigin,
-      methods: ['GET', 'POST', 'OPTIONS', 'PUT'],
+      methods: ['GET', 'POST', 'OPTIONS', 'PUT', 'DELETE'],
       allowedHeaders: envConfigService.corsAllowedHeaders,
     });
   }

packages/apps/reputation-oracle/server/src/modules/exchange-api-keys/exchange-api-keys.error-filter.ts

@@ -13,15 +13,13 @@ import {
   ExchangeApiKeyNotFoundError,
   IncompleteKeySuppliedError,
   KeyAuthorizationError,
-  ActiveExchangeApiKeyExistsError,
 } from './exchange-api-keys.errors';
 import { ExchangeApiClientError } from '../exchange/errors';
 
 @Catch(
   UserNotFoundError,
   IncompleteKeySuppliedError,
   KeyAuthorizationError,
-  ActiveExchangeApiKeyExistsError,
   ExchangeApiKeyNotFoundError,
 )
 export class ExchangeApiKeysControllerErrorsFilter implements ExceptionFilter {
@@ -38,8 +36,7 @@ export class ExchangeApiKeysControllerErrorsFilter implements ExceptionFilter {
     if (
       exception instanceof UserNotFoundError ||
       exception instanceof IncompleteKeySuppliedError ||
-      exception instanceof KeyAuthorizationError ||
-      exception instanceof ActiveExchangeApiKeyExistsError
+      exception instanceof KeyAuthorizationError
     ) {
       status = HttpStatus.UNPROCESSABLE_ENTITY;
     } else if (exception instanceof ExchangeApiClientError) {

packages/apps/reputation-oracle/server/src/modules/exchange-api-keys/exchange-api-keys.errors.ts

@@ -17,12 +17,3 @@ export class KeyAuthorizationError extends BaseError {
     super("Provided API key can't be authorized on exchange");
   }
 }
-
-export class ActiveExchangeApiKeyExistsError extends BaseError {
-  constructor(
-    readonly userId: number,
-    readonly exchangeName: string,
-  ) {
-    super('User already has an active exchange API key');
-  }
-}

packages/apps/reputation-oracle/server/src/modules/exchange-api-keys/exchange-api-keys.service.spec.ts

@@ -12,10 +12,7 @@ import { ExchangeApiKeysService } from './exchange-api-keys.service';
 import { UserEntity, UserNotFoundError, UserRepository } from '@/modules/user';
 
 import { ExchangeApiKeyEntity } from './exchange-api-key.entity';
-import {
-  ActiveExchangeApiKeyExistsError,
-  KeyAuthorizationError,
-} from './exchange-api-keys.errors';
+import { KeyAuthorizationError } from './exchange-api-keys.errors';
 import { ExchangeApiKeysRepository } from './exchange-api-keys.repository';
 import {
   generateExchangeApiKey,
@@ -104,20 +101,31 @@ describe('ExchangeApiKeysService', () => {
       expect(thrownError.exchangeName).toBe(input.exchangeName);
     });
 
-    it('should throw if user already has active keys', async () => {
+    it('should overwrite existing keys if user already has active ones', async () => {
       const input = generateExchangeApiKeysData();
+      const existingKey = generateExchangeApiKey();
       mockExchangeApiKeysRepository.findOneByUserId.mockResolvedValueOnce(
-        generateExchangeApiKey(),
+        existingKey,
+      );
+      mockExchangeClient.checkRequiredAccess.mockResolvedValueOnce(true);
+      mockUserRepository.findOneById.mockResolvedValueOnce({
+        id: input.userId,
+      } as UserEntity);
+      mockExchangeApiKeysRepository.updateOne.mockImplementation(
+        async (entity) => entity,
       );
 
-      let thrownError;
-      try {
-        await exchangeApiKeysService.enroll(input);
-      } catch (error) {
-        thrownError = error;
-      }
+      const updatedEntity = await exchangeApiKeysService.enroll(input);
 
-      expect(thrownError).toBeInstanceOf(ActiveExchangeApiKeyExistsError);
+      expect(mockExchangeApiKeysRepository.updateOne).toHaveBeenCalledWith(
+        existingKey,
+      );
+      const [decryptedApiKey, decryptedSecretKey] = await Promise.all([
+        aesEncryptionService.decrypt(updatedEntity.apiKey),
+        aesEncryptionService.decrypt(updatedEntity.secretKey),
+      ]);
+      expect(decryptedApiKey.toString()).toBe(input.apiKey);
+      expect(decryptedSecretKey.toString()).toBe(input.secretKey);
     });
 
     it('should throw if user not exists', async () => {

packages/apps/reputation-oracle/server/src/modules/exchange-api-keys/exchange-api-keys.service.ts

@@ -10,10 +10,7 @@ import { ExchangeClientFactory } from '@/modules/exchange/exchange-client.factor
 import { UserNotFoundError, UserRepository } from '@/modules/user';
 
 import { ExchangeApiKeyEntity } from './exchange-api-key.entity';
-import {
-  ActiveExchangeApiKeyExistsError,
-  KeyAuthorizationError,
-} from './exchange-api-keys.errors';
+import { KeyAuthorizationError } from './exchange-api-keys.errors';
 import { ExchangeApiKeysRepository } from './exchange-api-keys.repository';
 
 @Injectable()
@@ -39,9 +36,6 @@ export class ExchangeApiKeysService {
 
     const currentKeys =
       await this.exchangeApiKeysRepository.findOneByUserId(userId);
-    if (currentKeys) {
-      throw new ActiveExchangeApiKeyExistsError(userId, exchangeName);
-    }
 
     const client = await this.exchangeClientFactory.create(exchangeName, {
       apiKey,
@@ -57,14 +51,21 @@ export class ExchangeApiKeysService {
       throw new UserNotFoundError(userId);
     }
 
-    const enrolledKey = new ExchangeApiKeyEntity();
-    enrolledKey.userId = userId;
-    enrolledKey.exchangeName = exchangeName;
-
     const [encryptedApiKey, encryptedSecretKey] = await Promise.all([
       this.aesEncryptionService.encrypt(Buffer.from(apiKey)),
       this.aesEncryptionService.encrypt(Buffer.from(secretKey)),
     ]);
+    if (currentKeys) {
+      currentKeys.exchangeName = exchangeName;
+      currentKeys.apiKey = encryptedApiKey;
+      currentKeys.secretKey = encryptedSecretKey;
+
+      return this.exchangeApiKeysRepository.updateOne(currentKeys);
+    }
+
+    const enrolledKey = new ExchangeApiKeyEntity();
+    enrolledKey.userId = userId;
+    enrolledKey.exchangeName = exchangeName;
     enrolledKey.apiKey = encryptedApiKey;
     enrolledKey.secretKey = encryptedSecretKey;
     await this.exchangeApiKeysRepository.createUnique(enrolledKey);