feat(api-service): api for env level change fixes NV-6155

apps/api/package.json

@@ -78,6 +78,7 @@
     "compression": "^1.7.4",
     "cross-env": "^7.0.3",
     "date-fns": "^2.29.2",
+    "deep-object-diff": "^1.1.9",
     "dotenv": "^16.5.0",
     "envalid": "^8.0.0",
     "handlebars": "^4.7.7",
@@ -119,6 +120,7 @@
     "@nestjs/schematics": "10.1.4",
     "@nestjs/testing": "10.4.18",
     "@stoplight/spectral-cli": "^6.15.0",
+    "@swc-node/register": "^1.10.10",
     "@types/async": "^3.2.1",
     "@types/bcrypt": "^3.0.0",
     "@types/bull": "^3.15.8",
@@ -131,7 +133,6 @@
     "@types/passport-jwt": "^3.0.3",
     "@types/sinon": "^9.0.0",
     "@types/supertest": "^2.0.8",
-    "@swc-node/register": "^1.10.10",
     "async": "^3.2.0",
     "chai": "^4.2.0",
     "chai-subset": "^1.6.0",

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

@@ -1,4 +1,5 @@
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { EnvironmentTypeEnum } from '@novu/shared';
 import { ApiKeyDto } from './api-key.dto';
 
 export class EnvironmentResponseDto {
@@ -30,6 +31,14 @@ export class EnvironmentResponseDto {
   })
   identifier: string;
 
+  @ApiPropertyOptional({
+    enum: EnvironmentTypeEnum,
+    description: 'Type of the environment',
+    example: EnvironmentTypeEnum.PROD,
+    nullable: true,
+  })
+  type: EnvironmentTypeEnum;
+
   @ApiPropertyOptional({
     type: ApiKeyDto,
     isArray: true,

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

@@ -135,6 +135,7 @@ export class EnvironmentsControllerV1 {
         organizationId: user.organizationId,
         environmentId: user.environmentId,
         returnApiKeys: canAccessApiKeys,
+        userId: user._id,
       })
     );
   }

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

@@ -1,4 +1,5 @@
-import { IsBoolean, IsDefined, IsHexColor, IsMongoId, IsOptional, IsString } from 'class-validator';
+import { IsBoolean, IsDefined, IsEnum, IsHexColor, IsMongoId, IsOptional, IsString } from 'class-validator';
+import { EnvironmentTypeEnum } from '@novu/shared';
 import { OrganizationCommand } from '../../../shared/commands/organization.command';
 
 export class CreateEnvironmentCommand extends OrganizationCommand {
@@ -14,6 +15,10 @@ export class CreateEnvironmentCommand extends OrganizationCommand {
   @IsHexColor()
   color?: string;
 
+  @IsOptional()
+  @IsEnum(EnvironmentTypeEnum)
+  type?: EnvironmentTypeEnum;
+
   @IsBoolean()
   @IsDefined()
   system: boolean;

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

@@ -2,7 +2,7 @@ import { expect } from 'chai';
 
 import { EnvironmentRepository } from '@novu/dal';
 import { UserSession } from '@novu/testing';
-import { ApiServiceLevelEnum, NOVU_ENCRYPTION_SUB_MASK } from '@novu/shared';
+import { ApiServiceLevelEnum, NOVU_ENCRYPTION_SUB_MASK, EnvironmentTypeEnum, FeatureFlagsKeysEnum } from '@novu/shared';
 
 async function createEnv(name: string, session) {
   const demoEnvironment = {
@@ -23,6 +23,14 @@ describe('Create Environment - /environments (POST)', async () => {
       noEnvironment: true,
     });
     session.updateOrganizationServiceLevel(ApiServiceLevelEnum.BUSINESS);
+
+    // Enable the new change mechanism by default for normal tests
+    (process.env as any).IS_NEW_CHANGE_MECHANISM_ENABLED = 'true';
+  });
+
+  after(async () => {
+    // Clean up the feature flag
+    delete (process.env as any).IS_NEW_CHANGE_MECHANISM_ENABLED;
   });
 
   it('should create environment entity correctly', async () => {
@@ -48,6 +56,107 @@ describe('Create Environment - /environments (POST)', async () => {
     expect(dbApp.apiKeys[0]._userId).to.equal(session.user._id);
   });
 
+  it('should create environment with correct default type', async () => {
+    const demoEnvironment = {
+      name: 'Test Environment',
+      color: '#3A7F5C',
+    };
+    const { body } = await session.testAgent.post('/v1/environments').send(demoEnvironment).expect(201);
+
+    expect(body.data.name).to.eq(demoEnvironment.name);
+    expect(body.data.type).to.eq(EnvironmentTypeEnum.PROD);
+
+    const dbApp = await environmentRepository.findOne({ _id: body.data._id });
+    expect(dbApp?.type).to.equal(EnvironmentTypeEnum.PROD);
+  });
+
+  it('should create Development environment with DEV type', async () => {
+    const demoEnvironment = {
+      name: 'Development',
+      color: '#3A7F5C',
+    };
+    const { body } = await session.testAgent.post('/v1/environments').send(demoEnvironment).expect(201);
+
+    expect(body.data.name).to.eq(demoEnvironment.name);
+    expect(body.data.type).to.eq(EnvironmentTypeEnum.DEV);
+
+    const dbApp = await environmentRepository.findOne({ _id: body.data._id });
+    expect(dbApp?.type).to.equal(EnvironmentTypeEnum.DEV);
+  });
+
+  it('should create Production environment with PROD type', async () => {
+    const demoEnvironment = {
+      name: 'Production',
+      color: '#3A7F5C',
+    };
+    const { body } = await session.testAgent.post('/v1/environments').send(demoEnvironment).expect(201);
+
+    expect(body.data.name).to.eq(demoEnvironment.name);
+    expect(body.data.type).to.eq(EnvironmentTypeEnum.PROD);
+
+    const dbApp = await environmentRepository.findOne({ _id: body.data._id });
+    expect(dbApp?.type).to.equal(EnvironmentTypeEnum.PROD);
+  });
+
+  it('should default custom environments to PROD type', async () => {
+    const demoEnvironment = {
+      name: 'Staging Environment',
+      color: '#3A7F5C',
+    };
+    const { body } = await session.testAgent.post('/v1/environments').send(demoEnvironment).expect(201);
+
+    expect(body.data.name).to.eq(demoEnvironment.name);
+    expect(body.data.type).to.eq(EnvironmentTypeEnum.PROD);
+
+    const dbApp = await environmentRepository.findOne({ _id: body.data._id });
+    expect(dbApp?.type).to.equal(EnvironmentTypeEnum.PROD);
+  });
+
+  it('should create all environments with DEV type when IS_NEW_CHANGE_MECHANISM_ENABLED is disabled', async () => {
+    // Set the feature flag to disabled
+    (process.env as any).IS_NEW_CHANGE_MECHANISM_ENABLED = 'false';
+
+    const testCases = [
+      { name: 'Development', expectedType: EnvironmentTypeEnum.DEV },
+      { name: 'Production', expectedType: EnvironmentTypeEnum.DEV },
+      { name: 'Staging', expectedType: EnvironmentTypeEnum.DEV },
+      { name: 'Custom Environment', expectedType: EnvironmentTypeEnum.DEV },
+    ];
+
+    for (const testCase of testCases) {
+      const demoEnvironment = {
+        name: testCase.name,
+        color: '#3A7F5C',
+      };
+      const { body } = await session.testAgent.post('/v1/environments').send(demoEnvironment).expect(201);
+
+      expect(body.data.name).to.eq(demoEnvironment.name);
+      expect(body.data.type).to.eq(testCase.expectedType);
+
+      const dbApp = await environmentRepository.findOne({ _id: body.data._id });
+      expect(dbApp?.type).to.equal(testCase.expectedType);
+    }
+
+    // Reset the feature flag to enabled for other tests
+    (process.env as any).IS_NEW_CHANGE_MECHANISM_ENABLED = 'true';
+  });
+
+  it('should apply default type to existing environments without type field', async () => {
+    // Create an environment and manually remove the type field to simulate old data
+    const demoEnvironment = {
+      name: 'Legacy Environment',
+      color: '#3A7F5C',
+    };
+    const { body } = await session.testAgent.post('/v1/environments').send(demoEnvironment).expect(201);
+
+    // Manually remove the type field to simulate legacy data
+    await environmentRepository.update({ _id: body.data._id }, { $unset: { type: 1 } });
+
+    // Fetch the environment - should have default type applied
+    const fetchedEnv = await environmentRepository.findOne({ _id: body.data._id });
+    expect(fetchedEnv?.type).to.equal(EnvironmentTypeEnum.PROD);
+  });
+
   it('should fail when no name provided', async () => {
     const demoEnvironment = {};
     const { body } = await session.testAgent.post('/v1/environments').send(demoEnvironment).expect(400);

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

@@ -2,10 +2,10 @@ import { BadRequestException, Injectable, UnprocessableEntityException } from '@
 import { createHash } from 'crypto';
 import { nanoid } from 'nanoid';
 
-import { encryptApiKey } from '@novu/application-generic';
+import { encryptApiKey, FeatureFlagsService } from '@novu/application-generic';
 import { EnvironmentEntity, EnvironmentRepository, NotificationGroupRepository } from '@novu/dal';
 
-import { EnvironmentEnum, PROTECTED_ENVIRONMENTS } from '@novu/shared';
+import { EnvironmentEnum, EnvironmentTypeEnum, FeatureFlagsKeysEnum, 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-v1/usecases';
@@ -20,7 +20,8 @@ export class CreateEnvironment {
     private notificationGroupRepository: NotificationGroupRepository,
     private generateUniqueApiKey: GenerateUniqueApiKey,
     private createDefaultLayoutUsecase: CreateDefaultLayout,
-    private createNovuIntegrationsUsecase: CreateNovuIntegrations
+    private createNovuIntegrationsUsecase: CreateNovuIntegrations,
+    private featureFlagsService: FeatureFlagsService
   ) {}
 
   async execute(command: CreateEnvironmentCommand): Promise<EnvironmentResponseDto> {
@@ -63,12 +64,15 @@ export class CreateEnvironment {
       throw new BadRequestException('Color property is required');
     }
 
+    const type = await this.getEnvironmentType(command.name, command.organizationId, command.type);
+
     const environment = await this.environmentRepository.create({
       _organizationId: command.organizationId,
       name: normalizedName,
       identifier: nanoid(12),
       _parentId: command.parentEnvironmentId,
       color,
+      type,
       apiKeys: [
         {
           key: encryptedApiKey,
@@ -128,6 +132,7 @@ export class CreateEnvironment {
     dto._organizationId = environment._organizationId;
     dto.identifier = environment.identifier;
     dto._parentId = environment._parentId;
+    dto.type = environment.type;
 
     if (environment.apiKeys && environment.apiKeys.length > 0 && returnApiKeys) {
       dto.apiKeys = environment.apiKeys.map((apiKey) => ({
@@ -139,10 +144,34 @@ export class CreateEnvironment {
 
     return dto;
   }
+
   private getEnvironmentColor(name: string, commandColor?: string): string | undefined {
     if (name === EnvironmentEnum.DEVELOPMENT) return '#ff8547';
     if (name === EnvironmentEnum.PRODUCTION) return '#7e52f4';
 
     return commandColor;
   }
+
+  private async getEnvironmentType(
+    name: string,
+    organizationId: string,
+    commandType?: EnvironmentTypeEnum
+  ): Promise<EnvironmentTypeEnum> {
+    if (commandType) return commandType;
+
+    const isNewChangeMechanismEnabled = await this.featureFlagsService.getFlag({
+      key: FeatureFlagsKeysEnum.IS_NEW_CHANGE_MECHANISM_ENABLED,
+      organization: { _id: organizationId },
+      defaultValue: false,
+    });
+
+    if (!isNewChangeMechanismEnabled) {
+      return EnvironmentTypeEnum.DEV;
+    }
+
+    if (name === EnvironmentEnum.DEVELOPMENT) return EnvironmentTypeEnum.DEV;
+    if (name === EnvironmentEnum.PRODUCTION) return EnvironmentTypeEnum.PROD;
+
+    return EnvironmentTypeEnum.PROD;
+  }
 }

apps/api/src/app/environments-v1/usecases/get-my-environments/get-my-environments.command.ts

@@ -10,4 +10,7 @@ export class GetMyEnvironmentsCommand extends BaseCommand {
 
   @IsOptional()
   readonly returnApiKeys: boolean;
+
+  @IsOptional()
+  readonly userId: string;
 }

apps/api/src/app/environments-v1/usecases/get-my-environments/get-my-environments.usecase.ts

@@ -1,8 +1,8 @@
 import { Injectable, NotFoundException, Scope } from '@nestjs/common';
 
 import { EnvironmentEntity, EnvironmentRepository } from '@novu/dal';
-import { decryptApiKey, PinoLogger } from '@novu/application-generic';
-import { ShortIsPrefixEnum, EnvironmentEnum } from '@novu/shared';
+import { decryptApiKey, PinoLogger, FeatureFlagsService } from '@novu/application-generic';
+import { ShortIsPrefixEnum, EnvironmentEnum, FeatureFlagsKeysEnum, EnvironmentTypeEnum } from '@novu/shared';
 
 import { GetMyEnvironmentsCommand } from './get-my-environments.command';
 import { EnvironmentResponseDto } from '../../dtos/environment-response.dto';
@@ -14,7 +14,8 @@ import { buildSlug } from '../../../shared/helpers/build-slug';
 export class GetMyEnvironments {
   constructor(
     private environmentRepository: EnvironmentRepository,
-    private logger: PinoLogger
+    private logger: PinoLogger,
+    private featureFlagsService: FeatureFlagsService
   ) {
     this.logger.setContext(this.constructor.name);
   }
@@ -27,11 +28,18 @@ export class GetMyEnvironments {
     if (!environments?.length)
       throw new NotFoundException(`No environments were found for organization ${command.organizationId}`);
 
+    const isNewChangeMechanismEnabled = await this.isNewChangeMechanismEnabled(command);
+
     return environments.map((environment) => {
       const processedEnvironment = { ...environment };
 
       processedEnvironment.apiKeys = command.returnApiKeys ? this.decryptApiKeys(environment.apiKeys) : [];
 
+      // Override environment type to DEV if feature flag is disabled
+      if (!isNewChangeMechanismEnabled) {
+        processedEnvironment.type = EnvironmentTypeEnum.DEV;
+      }
+
       const shortEnvName = shortenEnvironmentName(processedEnvironment.name);
 
       return {
@@ -41,6 +49,14 @@ export class GetMyEnvironments {
     });
   }
 
+  private async isNewChangeMechanismEnabled(command: GetMyEnvironmentsCommand): Promise<boolean> {
+    return await this.featureFlagsService.getFlag({
+      key: FeatureFlagsKeysEnum.IS_NEW_CHANGE_MECHANISM_ENABLED,
+      defaultValue: false,
+      organization: { _id: command.organizationId },
+    });
+  }
+
   private decryptApiKeys(apiKeys: EnvironmentEntity['apiKeys']) {
     return apiKeys.map((apiKey) => ({
       ...apiKey,