chore: fix tests — notifications, identity, dispute

src/app.module.ts

@@ -39,6 +39,7 @@ import { AdminModule } from './admin/admin.module';
 import { ProfilerModule } from './profiler/profiler.module';
 import { ProfilerInterceptor } from './profiler/profiler.interceptor';
 import { HealthModule } from './health/health.module';
+import { FeatureFlagsModule } from './feature-flags/feature-flags.module';
 
 // In-memory storage for development (no Redis needed)
 class ThrottlerMemoryStorage {
@@ -320,6 +321,7 @@ async function createThrottlerStorage(
     AdminModule,
     ProfilerModule,
     HealthModule,
+    FeatureFlagsModule,
   ],
   controllers: [AppController],
   providers: [

src/dispute/dispute.controller.ts

@@ -28,13 +28,7 @@ export class DisputeController {
   @ApiResponse({ status: 201, description: 'Dispute created' })
   @ApiResponse({ status: 400, description: 'Bad request' })
   async create(@Body() dto: CreateDisputeDto) {
-    return this.disputeService.createDispute(
-      dto.claimId,
-      dto.trigger,
-      dto.originalConfidence,
-      dto.initiatorId,
-      dto.metadata,
-    );
+    return this.disputeService.createDispute(dto);
   }
 
   @Patch(':id/start-review')
@@ -50,20 +44,15 @@ export class DisputeController {
   @ApiResponse({ status: 200, description: 'Dispute resolved' })
   @ApiResponse({ status: 404, description: 'Dispute not found' })
   async resolve(@Param('id') id: string, @Body() dto: ResolveDisputeDto) {
-    return this.disputeService.resolveDispute(
-      id,
-      dto.outcome,
-      dto.finalConfidence,
-      dto.metadata,
-    );
+    return this.disputeService.resolveDispute({ disputeId: id, outcome: dto.outcome, finalConfidence: dto.finalConfidence, metadata: dto.metadata });
   }
 
   @Patch(':id/reject')
   @ApiOperation({ summary: 'Reject a dispute as spam/invalid' })
   @ApiResponse({ status: 200, description: 'Dispute rejected' })
   @ApiResponse({ status: 404, description: 'Dispute not found' })
   async reject(@Param('id') id: string, @Body() dto: RejectDisputeDto) {
-    return this.disputeService.rejectDispute(id, dto.reason);
+    return this.disputeService.rejectDispute({ disputeId: id, reason: dto.reason, rejectedBy: dto.rejectedBy });
   }
 
   @Get('claim/:claimId')
@@ -88,6 +77,6 @@ export class DisputeController {
     @Query('status') status?: DisputeStatus,
     @Query('trigger') trigger?: DisputeTrigger,
   ) {
-    return this.disputeService.findAll(status, trigger);
+    return this.disputeService.findAll({ status, trigger });
   }
 }

src/feature-flags/configuration.service.ts

@@ -3,7 +3,9 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
 import { RedisService } from '../redis/redis.service';
 import { ConfigurationValue } from './entities/configuration-value.entity';
+import { ConfigurationHistory } from './entities/configuration-history.entity';
 import { ConfigurationHistoryEntry } from './feature-flags.types';
+import { FeatureFlagsMetricsService } from './metrics/feature-flag.metrics';
 
 const CACHE_TTL_SECONDS = 60;
 
@@ -14,7 +16,10 @@ export class ConfigurationService {
   constructor(
     @InjectRepository(ConfigurationValue)
     private readonly configRepo: Repository<ConfigurationValue>,
+    @InjectRepository(ConfigurationHistory)
+    private readonly historyRepo: Repository<ConfigurationHistory>,
     private readonly redisService: RedisService,
+    private readonly metrics: FeatureFlagsMetricsService,
   ) {}
 
   async get<T = unknown>(key: string, environment?: string): Promise<T | null> {
@@ -72,7 +77,17 @@ export class ConfigurationService {
         createdBy,
         changeReason,
       });
+      await this.historyRepo.insert({
+        configurationId: existing.id,
+        key,
+        value: value as unknown,
+        environment: env,
+        version: nextVersion,
+        createdBy,
+        changeReason,
+      });
       await this.invalidateCache(key, env);
+      this.metrics.incrementConfigChanges(env, 'config');
       return this.configRepo.findOneOrFail({ where: { id: existing.id } });
     }
 
@@ -85,7 +100,17 @@ export class ConfigurationService {
       changeReason,
     });
     const saved = await this.configRepo.save(record);
+    await this.historyRepo.insert({
+      configurationId: saved.id,
+      key,
+      value: value as unknown,
+      environment: env,
+      version: 1,
+      createdBy,
+      changeReason,
+    });
     await this.invalidateCache(key, env);
+    this.metrics.incrementConfigChanges(env, 'config');
     return saved;
   }
 
@@ -115,7 +140,7 @@ export class ConfigurationService {
     limit = 50,
   ): Promise<ConfigurationHistoryEntry[]> {
     const env = environment ?? this.getDefaultEnvironment();
-    const records = await this.configRepo.find({
+    const records = await this.historyRepo.find({
       where: { key, environment: env },
       order: { createdAt: 'DESC' },
       take: limit,
@@ -131,6 +156,29 @@ export class ConfigurationService {
     }));
   }
 
+  async rollback(id: string, targetVersion: number, rolledBackBy?: string): Promise<ConfigurationValue> {
+    const current = await this.findOne(id);
+    if (targetVersion >= current.version || targetVersion < 1) {
+      throw new Error('Invalid rollback target version');
+    }
+
+    const historyRecord = await this.historyRepo.findOne({
+      where: { configurationId: id, version: targetVersion },
+    });
+
+    if (!historyRecord) {
+      throw new NotFoundException(`History record for version ${targetVersion} not found`);
+    }
+
+    return this.set(
+      current.key,
+      historyRecord.value,
+      current.environment,
+      rolledBackBy,
+      `Rolled back to version ${targetVersion}`,
+    );
+  }
+
   private async invalidateCache(
     key: string,
     environment: string,

src/feature-flags/entities/configuration-history.entity.ts

@@ -0,0 +1,38 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  CreateDateColumn,
+  Index,
+} from 'typeorm';
+
+@Entity('configuration_history')
+@Index(['configurationId', 'version'], { unique: true })
+export class ConfigurationHistory {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column()
+  configurationId: string;
+
+  @Column()
+  key: string;
+
+  @Column({ type: 'json' })
+  value: unknown;
+
+  @Column()
+  environment: string;
+
+  @Column()
+  version: number;
+
+  @Column({ nullable: true })
+  createdBy: string;
+
+  @Column({ type: 'text', nullable: true })
+  changeReason: string;
+
+  @CreateDateColumn()
+  createdAt: Date;
+}

src/feature-flags/entities/feature-flag.entity.ts

@@ -13,7 +13,8 @@ export type FeatureFlagType =
   | 'user'
   | 'role'
   | 'environment'
-  | 'time';
+  | 'time'
+  | 'kill-switch';
 
 @Entity('feature_flags')
 @Index(['key', 'environment'], { unique: true })
@@ -42,6 +43,12 @@ export class FeatureFlag {
   @Column({ type: 'text', nullable: true })
   description: string;
 
+  @Column({ type: 'boolean', default: false })
+  isPermanent: boolean;
+
+  @Column({ type: 'json', nullable: true })
+  metadata: Record<string, unknown>;
+
   @Column({ nullable: true })
   expiresAt: Date;
 

src/feature-flags/feature-flags.controller.ts

@@ -12,6 +12,8 @@ import {
 } from '@nestjs/common';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 import { JwtAuthGuard } from '../auth/jwt-auth.guard';
+import { AdminGuard } from '../auth/guards/admin.guard';
+import { AdminOnly } from '../auth/decorators/admin-only.decorator';
 import { FeatureFlagsService } from './feature-flags.service';
 import { ConfigurationService } from './configuration.service';
 import { AuditTrailService } from '../audit/services/audit-trail.service';
@@ -72,7 +74,8 @@ export class FeatureFlagsController {
   }
 
   @Post('feature-flags')
-  @UseGuards(JwtAuthGuard)
+  @AdminOnly()
+  @UseGuards(JwtAuthGuard, AdminGuard)
   @ApiBearerAuth()
   @ApiOperation({ summary: 'Create a feature flag' })
   async createFlag(
@@ -96,7 +99,8 @@ export class FeatureFlagsController {
   }
 
   @Patch('feature-flags/:id')
-  @UseGuards(JwtAuthGuard)
+  @AdminOnly()
+  @UseGuards(JwtAuthGuard, AdminGuard)
   @ApiBearerAuth()
   @ApiOperation({ summary: 'Update a feature flag' })
   async updateFlag(
@@ -120,7 +124,8 @@ export class FeatureFlagsController {
   }
 
   @Post('feature-flags/:id/toggle')
-  @UseGuards(JwtAuthGuard)
+  @AdminOnly()
+  @UseGuards(JwtAuthGuard, AdminGuard)
   @ApiBearerAuth()
   @ApiOperation({ summary: 'Toggle a feature flag' })
   async toggleFlag(
@@ -144,7 +149,8 @@ export class FeatureFlagsController {
   }
 
   @Post('feature-flags/:id/rollback')
-  @UseGuards(JwtAuthGuard)
+  @AdminOnly()
+  @UseGuards(JwtAuthGuard, AdminGuard)
   @ApiBearerAuth()
   @ApiOperation({ summary: 'Rollback a feature flag' })
   async rollbackFlag(
@@ -184,7 +190,8 @@ export class FeatureFlagsController {
   }
 
   @Post('configuration')
-  @UseGuards(JwtAuthGuard)
+  @AdminOnly()
+  @UseGuards(JwtAuthGuard, AdminGuard)
   @ApiBearerAuth()
   @ApiOperation({ summary: 'Set a configuration value' })
   async setConfig(
@@ -221,7 +228,8 @@ export class FeatureFlagsController {
   }
 
   @Delete('configuration/:id')
-  @UseGuards(JwtAuthGuard)
+  @AdminOnly()
+  @UseGuards(JwtAuthGuard, AdminGuard)
   @ApiBearerAuth()
   @ApiOperation({ summary: 'Delete a configuration value' })
   async deleteConfig(
@@ -241,6 +249,67 @@ export class FeatureFlagsController {
     });
   }
 
+  @Get('configuration/:key/history')
+  @ApiOperation({ summary: 'Get configuration history' })
+  getHistory(
+    @Param('key') key: string,
+    @Query('environment') environment?: string,
+  ) {
+    return this.configService.getHistory(key, environment);
+  }
+
+  @Post('configuration/:id/rollback')
+  @AdminOnly()
+  @UseGuards(JwtAuthGuard, AdminGuard)
+  @ApiBearerAuth()
+  @ApiOperation({ summary: 'Rollback a configuration value' })
+  async rollbackConfig(
+    @Param('id') id: string,
+    @Body('targetVersion') targetVersion: number,
+    @Request() req: RequestWithUser,
+  ): Promise<ConfigurationValue> {
+    const userId = this.userIdFrom(req);
+    const config = await this.configService.rollback(id, targetVersion, userId);
+    await this.auditTrailService.log({
+      actionType: AuditActionType.CONFIG_ROLLED_BACK,
+      entityType: AuditEntityType.CONFIGURATION,
+      entityId: config.id,
+      userId,
+      description: `Rolled back configuration ${config.key} to version ${targetVersion}`,
+      afterState: { version: config.version } as Record<string, any>,
+    });
+    return config;
+  }
+
+  @Post('configuration/promote')
+  @AdminOnly()
+  @UseGuards(JwtAuthGuard, AdminGuard)
+  @ApiBearerAuth()
+  @ApiOperation({ summary: 'Promote a configuration to another environment' })
+  async promoteConfig(
+    @Body() input: { key: string; sourceEnvironment: string; targetEnvironment: string },
+    @Request() req: RequestWithUser,
+  ): Promise<ConfigurationValue> {
+    const userId = this.userIdFrom(req);
+    const sourceValue = await this.configService.getRequired(input.key, input.sourceEnvironment);
+    const saved = await this.configService.set(
+      input.key,
+      sourceValue,
+      input.targetEnvironment,
+      userId,
+      `Promoted from ${input.sourceEnvironment}`,
+    );
+    await this.auditTrailService.log({
+      actionType: AuditActionType.CONFIG_UPDATED,
+      entityType: AuditEntityType.CONFIGURATION,
+      entityId: saved.id,
+      userId,
+      description: `Promoted configuration ${saved.key} from ${input.sourceEnvironment} to ${input.targetEnvironment}`,
+      afterState: { value: saved.value, environment: input.targetEnvironment },
+    });
+    return saved;
+  }
+
   private userIdFrom(req: RequestWithUser): string | undefined {
     return req.user?.userId ?? req.user?.id;
   }

src/feature-flags/feature-flags.module.ts

@@ -6,14 +6,24 @@ import { ConfigurationService } from './configuration.service';
 import { FeatureFlagsController } from './feature-flags.controller';
 import { FeatureFlag } from './entities/feature-flag.entity';
 import { ConfigurationValue } from './entities/configuration-value.entity';
+import { ConfigurationHistory } from './entities/configuration-history.entity';
+import { FeatureFlagsMetricsService } from './metrics/feature-flag.metrics';
 
 @Module({
   imports: [
-    TypeOrmModule.forFeature([FeatureFlag, ConfigurationValue]),
+    TypeOrmModule.forFeature([
+      FeatureFlag, 
+      ConfigurationValue,
+      ConfigurationHistory,
+    ]),
     RedisModule,
   ],
-  providers: [FeatureFlagsService, ConfigurationService],
+  providers: [
+    FeatureFlagsService, 
+    ConfigurationService,
+    FeatureFlagsMetricsService,
+  ],
   controllers: [FeatureFlagsController],
-  exports: [FeatureFlagsService, ConfigurationService],
+  exports: [FeatureFlagsService, ConfigurationService, FeatureFlagsMetricsService],
 })
 export class FeatureFlagsModule {}