feat: scheduled releases, recommendations cache, reports audit trail, and pagination

backend/src/recommendations/recommendation-cache.service.ts

@@ -0,0 +1,118 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { InjectRepository } from "@nestjs/typeorm";
+import { Repository } from "typeorm";
+import { RecommendationFeedback } from "./entities/recommendation-feedback.entity";
+
+interface CacheEntry {
+  data: any[];
+  expiresAt: number;
+}
+
+@Injectable()
+export class RecommendationCacheService {
+  private readonly logger = new Logger(RecommendationCacheService.name);
+  private readonly cacheTtlMs = 3600000;
+  private cache = new Map<string, CacheEntry>();
+
+  constructor(
+    @InjectRepository(RecommendationFeedback)
+    private readonly feedbackRepo: Repository<RecommendationFeedback>,
+  ) {}
+
+  getCacheKey(userId: string, type: 'track' | 'artist'): string {
+    return `recommendations:${type}:${userId}`;
+  }
+
+  async getTrackRecommendations(
+    userId: string,
+    limit: number = 20,
+  ): Promise<any[] | null> {
+    const cacheKey = this.getCacheKey(userId, 'track');
+    const entry = this.cache.get(cacheKey);
+
+    if (entry && entry.expiresAt > Date.now()) {
+      this.logger.debug(`Track recommendations cache hit for user ${userId}`);
+      return entry.data.slice(0, limit);
+    }
+
+    if (entry && entry.expiresAt <= Date.now()) {
+      this.cache.delete(cacheKey);
+    }
+
+    return null;
+  }
+
+  async setTrackRecommendations(
+    userId: string,
+    recommendations: any[],
+  ): Promise<void> {
+    const cacheKey = this.getCacheKey(userId, 'track');
+    this.cache.set(cacheKey, {
+      data: recommendations,
+      expiresAt: Date.now() + this.cacheTtlMs,
+    });
+    this.logger.debug(`Track recommendations cached for user ${userId}`);
+  }
+
+  async getArtistRecommendations(userId: string): Promise<any[] | null> {
+    const cacheKey = this.getCacheKey(userId, 'artist');
+    const entry = this.cache.get(cacheKey);
+
+    if (entry && entry.expiresAt > Date.now()) {
+      this.logger.debug(`Artist recommendations cache hit for user ${userId}`);
+      return entry.data;
+    }
+
+    if (entry && entry.expiresAt <= Date.now()) {
+      this.cache.delete(cacheKey);
+    }
+
+    return null;
+  }
+
+  async setArtistRecommendations(
+    userId: string,
+    recommendations: any[],
+  ): Promise<void> {
+    const cacheKey = this.getCacheKey(userId, 'artist');
+    this.cache.set(cacheKey, {
+      data: recommendations,
+      expiresAt: Date.now() + this.cacheTtlMs,
+    });
+    this.logger.debug(`Artist recommendations cached for user ${userId}`);
+  }
+
+  async invalidateUserCache(userId: string): Promise<void> {
+    this.cache.delete(this.getCacheKey(userId, 'track'));
+    this.cache.delete(this.getCacheKey(userId, 'artist'));
+    this.logger.debug(`Invalidated recommendation cache for user ${userId}`);
+  }
+
+  async recordFeedback(
+    userId: string,
+    trackId: string,
+    feedback: 'up' | 'down',
+  ): Promise<RecommendationFeedback> {
+    const existing = await this.feedbackRepo.findOne({
+      where: { userId, trackId },
+    });
+
+    const entry = existing || this.feedbackRepo.create({ userId, trackId });
+    entry.feedback = feedback;
+    const saved = await this.feedbackRepo.save(entry);
+
+    await this.invalidateUserCache(userId);
+
+    return saved;
+  }
+
+  async invalidateOnTipEvent(userId: string): Promise<void> {
+    await this.invalidateUserCache(userId);
+    this.logger.debug(`Invalidated cache due to tip event for user ${userId}`);
+  }
+
+  async invalidateOnFeedbackEvent(userId: string): Promise<void> {
+    await this.invalidateUserCache(userId);
+    this.logger.debug(`Invalidated cache due to feedback event for user ${userId}`);
+  }
+}

backend/src/recommendations/recommendations.module.ts

@@ -2,13 +2,14 @@ import { Module } from "@nestjs/common";
 import { TypeOrmModule } from "@nestjs/typeorm";
 import { RecommendationsController } from "./recommendations.controller";
 import { RecommendationsService } from "./recommendations.service";
+import { RecommendationCacheService } from "./recommendation-cache.service";
 import { RecommendationFeedback } from "./entities/recommendation-feedback.entity";
 import { AuthModule } from "../auth/auth.module";
 
 @Module({
   imports: [TypeOrmModule.forFeature([RecommendationFeedback]), AuthModule],
   controllers: [RecommendationsController],
-  providers: [RecommendationsService],
-  exports: [RecommendationsService],
+  providers: [RecommendationsService, RecommendationCacheService],
+  exports: [RecommendationsService, RecommendationCacheService],
 })
 export class RecommendationsModule {}

backend/src/recommendations/recommendations.service.ts

@@ -2,6 +2,7 @@ import { Injectable, Logger } from "@nestjs/common";
 import { InjectRepository } from "@nestjs/typeorm";
 import { Repository, DataSource } from "typeorm";
 import { RecommendationFeedback } from "./entities/recommendation-feedback.entity";
+import { RecommendationCacheService } from "./recommendation-cache.service";
 import { TipStatus } from "../tips/entities/tip.entity";
 
 type RecommendationTrackRow = {
@@ -23,26 +24,41 @@ export class RecommendationsService {
     @InjectRepository(RecommendationFeedback)
     private readonly feedbackRepo: Repository<RecommendationFeedback>,
     private readonly dataSource: DataSource,
+    private readonly cacheService: RecommendationCacheService,
   ) {}
 
   async getTrackRecommendations(
     userId: string,
     limit: number = 20,
   ): Promise<any[]> {
     const boundedLimit = Math.max(1, Math.min(limit, 50));
+
+    const cached = await this.cacheService.getTrackRecommendations(userId, boundedLimit);
+    if (cached) {
+      return cached;
+    }
+
     const tipCount = await this.getUserTipCount(userId);
 
+    let recommendations: any[];
     if (tipCount < 3) {
-      return this.getPopularTracks(boundedLimit);
+      recommendations = await this.getPopularTracks(boundedLimit);
+    } else {
+      const collaborative = await this.collaborativeFilter(userId, boundedLimit);
+      const contentBased = await this.contentBasedFilter(userId, boundedLimit);
+      recommendations = this.mergeRecommendations(collaborative, contentBased, boundedLimit);
     }
 
-    const collaborative = await this.collaborativeFilter(userId, boundedLimit);
-    const contentBased = await this.contentBasedFilter(userId, boundedLimit);
-
-    return this.mergeRecommendations(collaborative, contentBased, boundedLimit);
+    await this.cacheService.setTrackRecommendations(userId, recommendations);
+    return recommendations;
   }
 
   async getArtistRecommendations(userId: string): Promise<any[]> {
+    const cached = await this.cacheService.getArtistRecommendations(userId);
+    if (cached) {
+      return cached;
+    }
+
     const trackRecommendations = await this.getTrackRecommendations(userId, 30);
     const artists = new Map<string, any>();
 
@@ -67,27 +83,20 @@ export class RecommendationsService {
       });
     }
 
-    return [...artists.values()]
+    const recommendations = [...artists.values()]
       .sort((a, b) => b.score - a.score || b.trackCount - a.trackCount)
       .slice(0, 10);
+
+    await this.cacheService.setArtistRecommendations(userId, recommendations);
+    return recommendations;
   }
 
   async recordFeedback(
     userId: string,
     trackId: string,
     feedback: "up" | "down",
   ): Promise<RecommendationFeedback> {
-    const existing = await this.feedbackRepo.findOne({
-      where: { userId, trackId },
-    });
-
-    if (existing) {
-      existing.feedback = feedback;
-      return this.feedbackRepo.save(existing);
-    }
-
-    const entry = this.feedbackRepo.create({ userId, trackId, feedback });
-    return this.feedbackRepo.save(entry);
+    return this.cacheService.recordFeedback(userId, trackId, feedback);
   }
 
   private async getUserTipCount(userId: string): Promise<number> {

backend/src/reports/dto/report-query.dto.ts

@@ -0,0 +1,36 @@
+import { IsEnum, IsOptional, IsInt, Min, Max } from 'class-validator';
+import { Type } from 'class-transformer';
+import { ReportStatus, ReportEntityType, ReportPriority } from '../entities/report.entity';
+
+export class ReportQueryDto {
+  @IsOptional()
+  @IsEnum(ReportStatus)
+  status?: ReportStatus;
+
+  @IsOptional()
+  @IsEnum(ReportEntityType)
+  entityType?: ReportEntityType;
+
+  @IsOptional()
+  @IsEnum(ReportPriority)
+  priority?: ReportPriority;
+
+  @IsOptional()
+  assignedToId?: string;
+
+  @IsOptional()
+  escalated?: boolean;
+
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  @Max(100)
+  limit?: number = 20;
+
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(0)
+  offset?: number = 0;
+}