fix(api-service): bugs found in bug bash in regarding to 4 tiers (#7775)

Author: tatarco

.source

@@ -0,0 +1,24 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+
+export class ApiKeyDto {
+  @ApiProperty({
+    type: String,
+    description: 'API key',
+    example: 'sk_test_1234567890abcdef',
+  })
+  key: string;
+
+  @ApiProperty({
+    type: String,
+    description: 'User ID associated with the API key',
+    example: '60d5ecb8b3b3a30015f3e1a4',
+  })
+  _userId: string;
+
+  @ApiPropertyOptional({
+    type: String,
+    description: 'Hashed representation of the API key',
+    example: 'hash_value_here',
+  })
+  hash?: string;
+}

apps/api/src/app/environments-v1/dtos/api-key.dto.ts

@@ -2,18 +2,30 @@ import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { IsDefined, IsHexColor, IsMongoId, IsOptional, IsString } from 'class-validator';
 
 export class CreateEnvironmentRequestDto {
-  @ApiProperty()
-  @IsDefined()
-  @IsString()
+  @ApiProperty({
+    type: String,
+    description: 'Name of the environment to be created',
+    example: 'Production Environment',
+  })
+  @IsDefined({ message: 'Environment name is required' })
+  @IsString({ message: 'Environment name must be a string' })
   name: string;
 
-  @ApiPropertyOptional()
+  @ApiPropertyOptional({
+    type: String,
+    description: 'MongoDB ObjectId of the parent environment (optional)',
+    example: '60d5ecb8b3b3a30015f3e1a1',
+  })
   @IsOptional()
-  @IsMongoId()
+  @IsMongoId({ message: 'Parent ID must be a valid MongoDB ObjectId' })
   parentId?: string;
 
-  @ApiProperty()
-  @IsDefined()
-  @IsHexColor()
+  @ApiProperty({
+    type: String,
+    description: 'Hex color code for the environment',
+    example: '#3498db',
+  })
+  @IsDefined({ message: 'Environment color is required' })
+  @IsHexColor({ message: 'Color must be a valid hex color code' })
   color: string;
 }

apps/api/src/app/environments-v1/dtos/create-environment-request.dto.ts

@@ -1,30 +1,53 @@
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { ApiKeyDto } from './api-key.dto';
 
 export class EnvironmentResponseDto {
-  @ApiPropertyOptional()
-  _id?: string;
-
-  @ApiProperty()
+  @ApiProperty({
+    type: String,
+    description: 'Unique identifier of the environment',
+    example: '60d5ecb8b3b3a30015f3e1a1',
+  })
+  _id: string;
+
+  @ApiProperty({
+    type: String,
+    description: 'Name of the environment',
+    example: 'Production Environment',
+  })
   name: string;
 
-  @ApiProperty()
+  @ApiProperty({
+    type: String,
+    description: 'Organization ID associated with the environment',
+    example: '60d5ecb8b3b3a30015f3e1a2',
+  })
   _organizationId: string;
 
-  @ApiProperty()
+  @ApiProperty({
+    type: String,
+    description: 'Unique identifier for the environment',
+    example: 'prod-env-01',
+  })
   identifier: string;
 
-  @ApiPropertyOptional()
-  apiKeys?: IApiKeyDto[];
-
-  @ApiProperty()
-  _parentId: string;
-
-  @ApiPropertyOptional()
+  @ApiPropertyOptional({
+    type: ApiKeyDto,
+    isArray: true,
+    description: 'List of API keys associated with the environment',
+  })
+  apiKeys?: ApiKeyDto[];
+
+  @ApiPropertyOptional({
+    type: String,
+    description: 'Parent environment ID',
+    example: '60d5ecb8b3b3a30015f3e1a3',
+  })
+  _parentId?: string;
+
+  @ApiPropertyOptional({
+    type: String,
+    description: 'URL-friendly slug for the environment',
+    example: 'production',
+  })
   slug?: string;
 }
-
-export interface IApiKeyDto {
-  key: string;
-  _userId: string;
-  hash?: string;
-}

apps/api/src/app/environments-v1/dtos/environment-response.dto.ts

@@ -0,0 +1,56 @@
+import { ApiServiceLevelEnum } from '@novu/shared';
+import { UserSession } from '@novu/testing';
+import { expect } from 'chai';
+import { Novu } from '@novu/api';
+import { expectSdkExceptionGeneric, initNovuClassSdkInternalAuth } from '../../shared/helpers/e2e/sdk/e2e-sdk.helper';
+
+describe('Env Controller', async () => {
+  let session: UserSession;
+  let novuClient: Novu;
+  before(async () => {
+    session = new UserSession();
+    await session.initialize({});
+    novuClient = initNovuClassSdkInternalAuth(session);
+  });
+  describe('Create Env', () => {
+    [ApiServiceLevelEnum.BUSINESS, ApiServiceLevelEnum.ENTERPRISE].forEach((serviceLevel) => {
+      it(`should be able to create env in ${serviceLevel} tier`, async () => {
+        await session.updateOrganizationServiceLevel(serviceLevel);
+        const { name, environmentRequestDto } = generateRandomEnvRequest();
+        const createdEnv = await novuClient.environments.create(environmentRequestDto);
+        const { result } = createdEnv;
+        expect(result).to.be.ok;
+        expect(result.name).to.equal(name);
+      });
+    });
+
+    [ApiServiceLevelEnum.PRO, ApiServiceLevelEnum.FREE].forEach((serviceLevel) => {
+      it(`should not be able to create env in ${serviceLevel} tier`, async () => {
+        await session.updateOrganizationServiceLevel(serviceLevel);
+        const { error, successfulBody } = await expectSdkExceptionGeneric(() =>
+          novuClient.environments.create(generateRandomEnvRequest().environmentRequestDto)
+        );
+        expect(error).to.be.ok;
+        expect(error?.message).to.equal('Payment Required');
+        expect(error?.statusCode).to.equal(402);
+      });
+    });
+  });
+  function generateRandomEnvRequest() {
+    const name = generateRandomName('env');
+    const parentId = session.environment._id;
+    const environmentRequestDto = {
+      name,
+      parentId,
+      color: '#b15353',
+    };
+
+    return { name, parentId, environmentRequestDto };
+  }
+});
+function generateRandomName(prefix: string = 'env'): string {
+  const timestamp = Date.now();
+  const randomPart = Math.random().toString(36).substring(2, 7);
+
+  return `${prefix}-${randomPart}-${timestamp}`;
+}

apps/api/src/app/environments-v1/e2e/environments.controller.e2e.ts

@@ -10,15 +10,15 @@ import {
   UseGuards,
   UseInterceptors,
 } from '@nestjs/common';
-import { ApiExcludeController, ApiExcludeEndpoint, ApiOperation, ApiParam, ApiTags } from '@nestjs/swagger';
+import { ApiExcludeEndpoint, ApiOperation, ApiParam, ApiTags } from '@nestjs/swagger';
 import { Roles } from '@novu/application-generic';
 import { ApiAuthSchemeEnum, MemberRoleEnum, ProductFeatureKeyEnum, UserSessionData } from '@novu/shared';
 import { ExternalApiAccessible } from '../auth/framework/external-api.decorator';
 import { ProductFeature } from '../shared/decorators/product-feature.decorator';
 import { ApiKey } from '../shared/dtos/api-key';
 import { ApiCommonResponses, ApiResponse } from '../shared/framework/response.decorator';
 import { UserAuthentication } from '../shared/framework/swagger/api.key.security';
-import { SdkGroupName } from '../shared/framework/swagger/sdk.decorators';
+import { SdkGroupName, SdkMethodName } from '../shared/framework/swagger/sdk.decorators';
 import { UserSession } from '../shared/framework/user.decorator';
 import { CreateEnvironmentRequestDto } from './dtos/create-environment-request.dto';
 import { EnvironmentResponseDto } from './dtos/environment-response.dto';
@@ -36,6 +36,7 @@ import { RegenerateApiKeys } from './usecases/regenerate-api-keys/regenerate-api
 import { UpdateEnvironmentCommand } from './usecases/update-environment/update-environment.command';
 import { UpdateEnvironment } from './usecases/update-environment/update-environment.usecase';
 import { RolesGuard } from '../auth/framework/roles.guard';
+import { ErrorDto } from '../../error-dto';
 
 /**
  * @deprecated use EnvironmentsControllerV2
@@ -45,7 +46,6 @@ import { RolesGuard } from '../auth/framework/roles.guard';
 @UseInterceptors(ClassSerializerInterceptor)
 @UserAuthentication()
 @ApiTags('Environments')
-@ApiExcludeController()
 export class EnvironmentsControllerV1 {
   constructor(
     private createEnvironmentUsecase: CreateEnvironment,
@@ -63,6 +63,7 @@ export class EnvironmentsControllerV1 {
   })
   @ApiResponse(EnvironmentResponseDto)
   @ExternalApiAccessible()
+  @ApiExcludeEndpoint()
   async getCurrentEnvironment(@UserSession() user: UserSessionData): Promise<EnvironmentResponseDto> {
     return await this.getEnvironmentUsecase.execute(
       GetEnvironmentCommand.create({
@@ -77,11 +78,13 @@ export class EnvironmentsControllerV1 {
   @ApiOperation({
     summary: 'Create environment',
   })
-  @ApiExcludeEndpoint()
   @ApiResponse(EnvironmentResponseDto, 201)
+  @ApiResponse(ErrorDto, 402, false, false)
   @ProductFeature(ProductFeatureKeyEnum.MANAGE_ENVIRONMENTS)
   @UseGuards(RolesGuard)
   @Roles(MemberRoleEnum.ADMIN)
+  @SdkGroupName('Environments')
+  @SdkMethodName('create')
   async createEnvironment(
     @UserSession() user: UserSessionData,
     @Body() body: CreateEnvironmentRequestDto
@@ -103,6 +106,7 @@ export class EnvironmentsControllerV1 {
   })
   @ApiResponse(EnvironmentResponseDto, 200, true)
   @ExternalApiAccessible()
+  @ApiExcludeEndpoint()
   async listMyEnvironments(@UserSession() user: UserSessionData): Promise<EnvironmentResponseDto[]> {
     return await this.getMyEnvironmentsUsecase.execute(
       GetMyEnvironmentsCommand.create({
@@ -146,6 +150,7 @@ export class EnvironmentsControllerV1 {
   @ApiResponse(ApiKey, 200, true)
   @ExternalApiAccessible()
   @SdkGroupName('Environments.ApiKeys')
+  @ApiExcludeEndpoint()
   async listOrganizationApiKeys(@UserSession() user: UserSessionData): Promise<ApiKey[]> {
     const command = GetApiKeysCommand.create({
       userId: user._id,
@@ -160,6 +165,7 @@ export class EnvironmentsControllerV1 {
   @ApiResponse(ApiKey, 201, true)
   @UseGuards(RolesGuard)
   @Roles(MemberRoleEnum.ADMIN)
+  @ApiExcludeEndpoint()
   async regenerateOrganizationApiKeys(@UserSession() user: UserSessionData): Promise<ApiKey[]> {
     const command = GetApiKeysCommand.create({
       userId: user._id,
@@ -178,6 +184,7 @@ export class EnvironmentsControllerV1 {
   @ProductFeature(ProductFeatureKeyEnum.MANAGE_ENVIRONMENTS)
   @UseGuards(RolesGuard)
   @Roles(MemberRoleEnum.ADMIN)
+  @ApiExcludeEndpoint()
   async deleteEnvironment(@UserSession() user: UserSessionData, @Param('environmentId') environmentId: string) {
     return await this.deleteEnvironmentUsecase.execute(
       DeleteEnvironmentCommand.create({

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

@@ -3,14 +3,15 @@ import { createHash } from 'crypto';
 import { nanoid } from 'nanoid';
 
 import { encryptApiKey } from '@novu/application-generic';
-import { EnvironmentRepository, NotificationGroupRepository } from '@novu/dal';
+import { EnvironmentEntity, EnvironmentRepository, NotificationGroupRepository } from '@novu/dal';
 
 import { EnvironmentEnum, PROTECTED_ENVIRONMENTS } from '@novu/shared';
 import { CreateNovuIntegrationsCommand } from '../../../integrations/usecases/create-novu-integrations/create-novu-integrations.command';
 import { CreateNovuIntegrations } from '../../../integrations/usecases/create-novu-integrations/create-novu-integrations.usecase';
 import { CreateDefaultLayout, CreateDefaultLayoutCommand } from '../../../layouts/usecases';
 import { GenerateUniqueApiKey } from '../generate-unique-api-key/generate-unique-api-key.usecase';
 import { CreateEnvironmentCommand } from './create-environment.command';
+import { EnvironmentResponseDto } from '../../dtos/environment-response.dto';
 
 @Injectable()
 export class CreateEnvironment {
@@ -22,11 +23,7 @@ export class CreateEnvironment {
     private createNovuIntegrationsUsecase: CreateNovuIntegrations
   ) {}
 
-  async execute(command: CreateEnvironmentCommand) {
-    const environmentCount = await this.environmentRepository.count({
-      _organizationId: command.organizationId,
-    });
-
+  async execute(command: CreateEnvironmentCommand): Promise<EnvironmentResponseDto> {
     const normalizedName = command.name.trim();
 
     if (!command.system) {
@@ -108,9 +105,28 @@ export class CreateEnvironment {
       })
     );
 
-    return environment;
+    return this.convertEnvironmentEntityToDto(environment);
   }
 
+  private convertEnvironmentEntityToDto(environment: EnvironmentEntity) {
+    const dto = new EnvironmentResponseDto();
+
+    dto._id = environment._id;
+    dto.name = environment.name;
+    dto._organizationId = environment._organizationId;
+    dto.identifier = environment.identifier;
+    dto._parentId = environment._parentId;
+
+    if (environment.apiKeys && environment.apiKeys.length > 0) {
+      dto.apiKeys = environment.apiKeys.map((apiKey) => ({
+        key: apiKey.key,
+        hash: apiKey.hash,
+        _userId: apiKey._userId,
+      }));
+    }
+
+    return dto;
+  }
   private getEnvironmentColor(name: string, commandColor?: string): string | undefined {
     if (name === EnvironmentEnum.DEVELOPMENT) return '#ff8547';
     if (name === EnvironmentEnum.PRODUCTION) return '#7e52f4';

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

@@ -7,7 +7,8 @@ import { decryptApiKey, encryptApiKey } from '@novu/application-generic';
 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';
-import { IApiKeyDto } from '../../dtos/environment-response.dto';
+
+import { ApiKeyDto } from '../../dtos/api-key.dto';
 
 @Injectable()
 export class RegenerateApiKeys {
@@ -16,7 +17,7 @@ export class RegenerateApiKeys {
     private generateUniqueApiKey: GenerateUniqueApiKey
   ) {}
 
-  async execute(command: GetApiKeysCommand): Promise<IApiKeyDto[]> {
+  async execute(command: GetApiKeysCommand): Promise<ApiKeyDto[]> {
     const environment = await this.environmentRepository.findOne({ _id: command.environmentId });
 
     if (!environment) {

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

@@ -17,6 +17,18 @@ export function initNovuClassSdk(session: UserSession, shouldRetry: boolean = fa
 
   return new Novu(options);
 }
+export function initNovuClassSdkInternalAuth(session: UserSession, shouldRetry: boolean = false): Novu {
+  const options: SDKOptions = {
+    security: { bearerAuth: session.token },
+    serverURL: session.serverUrl,
+    debugLogger: console,
+  };
+  if (!shouldRetry) {
+    options.retryConfig = { strategy: 'none' };
+  }
+
+  return new Novu(options);
+}
 export function initNovuFunctionSdk(session: UserSession): NovuCore {
   return new NovuCore({ security: { secretKey: session.apiKey }, serverURL: session.serverUrl });
 }