Merge branch 'main' into fix/api-script-e2e

.eslintrc.js

@@ -90,5 +90,11 @@ module.exports = {
         leadingUnderscore: 'allow',
       },
     ],
+    'prettier/prettier': [
+      'error',
+      {
+        endOfLine: 'auto',
+      },
+    ],
   },
 };

apps/api/e2e/api/environment/regenerate-api-keys.e2e.ts

@@ -0,0 +1,31 @@
+import { UserSession } from '@novu/testing';
+import { expect } from 'chai';
+
+describe('Environment - Regenerate Api Key', async () => {
+  let session: UserSession;
+
+  before(async () => {
+    session = new UserSession();
+    await session.initialize();
+  });
+
+  it('should regenerate an Api Key', async () => {
+    const {
+      body: { data: oldApiKeys },
+    } = await session.testAgent.get('/v1/environments/api-keys').send({});
+    const oldApiKey = oldApiKeys[0].key;
+
+    const {
+      body: { data: newApiKeys },
+    } = await session.testAgent.post('/v1/environments/api-keys/regenerate').send({});
+    const newApiKey = newApiKeys[0].key;
+
+    expect(oldApiKey).to.not.equal(newApiKey);
+
+    const {
+      body: { data: organizations },
+    } = await session.testAgent.get('/v1/organizations').send({});
+
+    expect(organizations).not.to.be.empty;
+  });
+});

apps/api/src/app/environments/environments.controller.ts

@@ -26,6 +26,7 @@ import { ApiCreatedResponse, ApiOkResponse, ApiOperation, ApiTags } from '@nestj
 import { ApiKey } from '../shared/dtos/api-key';
 import { EnvironmentResponseDto } from './dtos/environment-response.dto';
 import { ExternalApiAccessible } from '../auth/framework/external-api.decorator';
+import { RegenerateApiKeys } from './usecases/regenerate-api-keys/regenerate-api-keys.usecase';
 
 @Controller('/environments')
 @UseInterceptors(ClassSerializerInterceptor)
@@ -35,6 +36,7 @@ export class EnvironmentsController {
   constructor(
     private createEnvironmentUsecase: CreateEnvironment,
     private getApiKeysUsecase: GetApiKeys,
+    private regenerateApiKeysUsecase: RegenerateApiKeys,
     private getEnvironmentUsecase: GetEnvironment,
     private getMyEnvironmentsUsecase: GetMyEnvironments,
     private updateWidgetSettingsUsecase: UpdateWidgetSettings
@@ -116,6 +118,24 @@ export class EnvironmentsController {
     return await this.getApiKeysUsecase.execute(command);
   }
 
+  @Post('/api-keys/regenerate')
+  @ApiOperation({
+    summary: 'Regenerate api keys',
+  })
+  @ApiOkResponse({
+    type: [ApiKey],
+  })
+  @ExternalApiAccessible()
+  async regenerateOrganizationApiKeys(@UserSession() user: IJwtPayload): Promise<ApiKey[]> {
+    const command = GetApiKeysCommand.create({
+      userId: user._id,
+      organizationId: user.organizationId,
+      environmentId: user.environmentId,
+    });
+
+    return await this.regenerateApiKeysUsecase.execute(command);
+  }
+
   @Put('/widget/settings')
   @ApiOperation({
     summary: 'Update widget settings',

apps/api/src/app/environments/usecases/create-environment/create-environment.usecase.ts

@@ -1,28 +1,33 @@
 import { Injectable } from '@nestjs/common';
 import { EnvironmentRepository } from '@novu/dal';
-import * as hat from 'hat';
 import { nanoid } from 'nanoid';
+
+import { CreateEnvironmentCommand } from './create-environment.command';
+
+import { GenerateUniqueApiKey } from '../generate-unique-api-key/generate-unique-api-key.usecase';
 // eslint-disable-next-line max-len
 import { CreateNotificationGroupCommand } from '../../../notification-groups/usecases/create-notification-group/create-notification-group.command';
 import { CreateNotificationGroup } from '../../../notification-groups/usecases/create-notification-group/create-notification-group.usecase';
-import { CreateEnvironmentCommand } from './create-environment.command';
 
 @Injectable()
 export class CreateEnvironment {
   constructor(
     private environmentRepository: EnvironmentRepository,
-    private createNotificationGroup: CreateNotificationGroup
+    private createNotificationGroup: CreateNotificationGroup,
+    private generateUniqueApiKey: GenerateUniqueApiKey
   ) {}
 
   async execute(command: CreateEnvironmentCommand) {
+    const key = await this.generateUniqueApiKey.execute();
+
     const environment = await this.environmentRepository.create({
       _organizationId: command.organizationId,
       name: command.name,
       identifier: nanoid(12),
       _parentId: command.parentEnvironmentId,
       apiKeys: [
         {
-          key: hat(),
+          key,
           _userId: command.userId,
         },
       ],

apps/api/src/app/environments/usecases/generate-unique-api-key/generate-unique-api-key.spec.ts

@@ -0,0 +1,64 @@
+import { EnvironmentRepository } from '@novu/dal';
+import { InternalServerErrorException } from '@nestjs/common';
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+
+import { GenerateUniqueApiKey } from './generate-unique-api-key.usecase';
+
+const environmentRepository = new EnvironmentRepository();
+const generateUniqueApiKey = new GenerateUniqueApiKey(environmentRepository);
+
+let generateApiKeyStub;
+let findByApiKeyStub;
+describe('Generate Unique Api Key', () => {
+  beforeEach(() => {
+    findByApiKeyStub = sinon.stub(environmentRepository, 'findByApiKey');
+    generateApiKeyStub = sinon.stub(generateUniqueApiKey, 'generateApiKey' as any);
+  });
+
+  afterEach(() => {
+    findByApiKeyStub.restore();
+    generateApiKeyStub.restore();
+  });
+
+  it('should generate an API key for the environment without any clashing', async () => {
+    const expectedApiKey = 'expected-api-key';
+    generateApiKeyStub.onFirstCall().returns(expectedApiKey);
+
+    const apiKey = await generateUniqueApiKey.execute();
+
+    expect(typeof apiKey).to.be.string;
+    expect(apiKey).to.be.equal(expectedApiKey);
+  });
+
+  it('should generate a different valid API key after first one clashes with an existing one', async () => {
+    const clashingApiKey = 'clashing-api-key';
+    const expectedApiKey = 'expected-api-key';
+    generateApiKeyStub.onFirstCall().returns(clashingApiKey);
+    generateApiKeyStub.onSecondCall().returns(expectedApiKey);
+    findByApiKeyStub.onFirstCall().returns({ key: clashingApiKey });
+    findByApiKeyStub.onSecondCall().returns(undefined);
+
+    const apiKey = await generateUniqueApiKey.execute();
+    expect(typeof apiKey).to.be.string;
+    expect(apiKey).to.be.equal(expectedApiKey);
+  });
+
+  it('should throw an error if the generation clashes 3 times', async () => {
+    const clashingApiKey = 'clashing-api-key';
+    generateApiKeyStub.onFirstCall().returns(clashingApiKey);
+    generateApiKeyStub.onSecondCall().returns(clashingApiKey);
+    generateApiKeyStub.onThirdCall().returns(clashingApiKey);
+    findByApiKeyStub.onFirstCall().returns({ key: clashingApiKey });
+    findByApiKeyStub.onSecondCall().returns({ key: clashingApiKey });
+    findByApiKeyStub.onThirdCall().returns({ key: clashingApiKey });
+
+    try {
+      await generateUniqueApiKey.execute();
+      throw new Error('Should not reach here');
+    } catch (e) {
+      expect(e).to.be.instanceOf(InternalServerErrorException);
+      expect(e.message).to.eql('Clashing of the API key generation');
+    }
+  });
+});

apps/api/src/app/environments/usecases/generate-unique-api-key/generate-unique-api-key.usecase.ts

@@ -0,0 +1,39 @@
+import { Injectable, InternalServerErrorException } from '@nestjs/common';
+import { EnvironmentRepository } from '@novu/dal';
+import * as hat from 'hat';
+
+const API_KEY_GENERATION_MAX_RETRIES = 3;
+
+@Injectable()
+export class GenerateUniqueApiKey {
+  constructor(private environmentRepository: EnvironmentRepository) {}
+
+  async execute(): Promise<string> {
+    let apiKey: string;
+    let count = 0;
+    let isApiKeyUsed = true;
+    while (isApiKeyUsed) {
+      apiKey = this.generateApiKey();
+      const environment = await this.environmentRepository.findByApiKey(apiKey);
+      isApiKeyUsed = environment ? true : false;
+      count += 1;
+
+      if (count === API_KEY_GENERATION_MAX_RETRIES) {
+        const errorMessage = 'Clashing of the API key generation';
+        throw new InternalServerErrorException(new Error(errorMessage), errorMessage);
+      }
+    }
+
+    return apiKey;
+  }
+
+  /**
+   * Extracting the generation functionality so it can be stubbed for functional testing
+   *
+   * @requires hat
+   * @todo Dependency is no longer accessible to source code due of removal from Github. Consider look for an alternative.
+   */
+  private generateApiKey(): string {
+    return hat();
+  }
+}

apps/api/src/app/environments/usecases/index.ts

@@ -1,13 +1,17 @@
 import { CreateEnvironment } from './create-environment/create-environment.usecase';
+import { GenerateUniqueApiKey } from './generate-unique-api-key/generate-unique-api-key.usecase';
 import { GetApiKeys } from './get-api-keys/get-api-keys.usecase';
+import { RegenerateApiKeys } from './regenerate-api-keys/regenerate-api-keys.usecase';
 import { GetEnvironment } from './get-environment';
 import { GetMyEnvironments } from './get-my-environments/get-my-environments.usecase';
 import { UpdateWidgetSettings } from './update-widget-settings/update-widget-settings.usecase';
 
 export const USE_CASES = [
   //
   CreateEnvironment,
+  GenerateUniqueApiKey,
   GetApiKeys,
+  RegenerateApiKeys,
   GetEnvironment,
   GetMyEnvironments,
   UpdateWidgetSettings,

apps/api/src/app/environments/usecases/regenerate-api-keys/regenerate-api-keys.usecase.ts

@@ -0,0 +1,25 @@
+import { Injectable } from '@nestjs/common';
+import { IApiKey, EnvironmentRepository } from '@novu/dal';
+import { ApiException } from '../../../shared/exceptions/api.exception';
+import { GenerateUniqueApiKey } from '../generate-unique-api-key/generate-unique-api-key.usecase';
+import { GetApiKeysCommand } from '../get-api-keys/get-api-keys.command';
+
+@Injectable()
+export class RegenerateApiKeys {
+  constructor(
+    private environmentRepository: EnvironmentRepository,
+    private generateUniqueApiKey: GenerateUniqueApiKey
+  ) {}
+
+  async execute(command: GetApiKeysCommand): Promise<IApiKey[]> {
+    const environment = await this.environmentRepository.findById(command.environmentId);
+
+    if (!environment) {
+      throw new ApiException(`Environment id: ${command.environmentId} not found`);
+    }
+
+    const key = await this.generateUniqueApiKey.execute();
+
+    return await this.environmentRepository.updateApiKey(command.environmentId, key, command.userId);
+  }
+}