From 39f0442cb218907690d66b25303237c8e57bf892 Mon Sep 17 00:00:00 2001
From: ALEX AKPOJOSEVBE <alexakpojosevbe40@gmail.com>
Date: Mon, 29 Jun 2026 11:27:30 -0700
Subject: [PATCH] Changes made

Replaced unbounded Map with LRU cache (capped at 1000 entries) to prevent memory leaks from uncontrolled autocomplete cache growth. Removed manual timestamp-based TTL logic in favor of LRU cache's native 5-minute TTL enforcement. Added tests verifying cache eviction when cap is reached and TTL configuration.
---
 src/search/search.service.spec.ts | 45 +++++++++++++++++++++++++++++++
 src/search/search.service.ts      | 16 +++++++----
 2 files changed, 56 insertions(+), 5 deletions(-)

diff --git a/src/search/search.service.spec.ts b/src/search/search.service.spec.ts
index 2f49a2f1..dbcf927a 100644
--- a/src/search/search.service.spec.ts
+++ b/src/search/search.service.spec.ts
@@ -12,7 +12,9 @@ const mockQueryBuilder = {
   orderBy: jest.fn().mockReturnThis(),
   skip: jest.fn().mockReturnThis(),
   take: jest.fn().mockReturnThis(),
+  select: jest.fn().mockReturnThis(),
   getManyAndCount: jest.fn().mockResolvedValue([[], 0]),
+  getMany: jest.fn().mockResolvedValue([]),
 };
 
 const mockCourseRepo = {
@@ -105,4 +107,47 @@ describe('SearchService', () => {
     expect(result).toBeDefined();
     expect(Date.now() - start).toBeLessThan(100);
   });
+
+  describe('Autocomplete LRU Cache', () => {
+    it('should evict oldest entries when cache cap is reached', async () => {
+      const mockCourses = [
+        { id: '1', title: 'Course 1' },
+        { id: '2', title: 'Course 2' },
+      ];
+      mockQueryBuilder.getMany.mockResolvedValue(mockCourses);
+
+      // Fill cache beyond its max size (1000 entries)
+      for (let i = 0; i < 1001; i++) {
+        await service.getAutoComplete(`query${i}`);
+      }
+
+      // First entry should have been evicted
+      const firstResult = await service.getAutoComplete('query0');
+      expect(mockQueryBuilder.getMany).toHaveBeenCalled(); // Cache miss, so DB query is made
+
+      // Last entry should still be cached
+      mockQueryBuilder.getMany.mockClear();
+      const lastResult = await service.getAutoComplete('query1000');
+      expect(mockQueryBuilder.getMany).not.toHaveBeenCalled(); // Cache hit, no DB query
+    });
+
+    it('should enforce TTL via cache backend', async () => {
+      const mockCourses = [{ id: '1', title: 'Course 1' }];
+      mockQueryBuilder.getMany.mockResolvedValue(mockCourses);
+
+      // First call - cache miss
+      await service.getAutoComplete('test');
+      expect(mockQueryBuilder.getMany).toHaveBeenCalledTimes(1);
+
+      // Second call immediately - cache hit
+      await service.getAutoComplete('test');
+      expect(mockQueryBuilder.getMany).toHaveBeenCalledTimes(1);
+
+      // Wait for TTL to expire (300000ms = 5 minutes)
+      // In test, we can't actually wait 5 minutes, but we verify the TTL is configured
+      // The LRU cache handles TTL automatically, so we just verify the cache is using TTL
+      const cache = (service as any).autocompleteCache;
+      expect(cache.options.ttl).toBe(300000);
+    });
+  });
 });
diff --git a/src/search/search.service.ts b/src/search/search.service.ts
index b5e9e3ff..6891a920 100644
--- a/src/search/search.service.ts
+++ b/src/search/search.service.ts
@@ -5,6 +5,7 @@ import type { Cache } from 'cache-manager';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
 import { Course } from '../courses/entities/course.entity';
+import { LRUCache } from 'lru-cache';
 
 export interface SearchFilters {
   category?: string | string[];
@@ -37,15 +38,20 @@ export class SearchService {
   private readonly logger = new Logger(SearchService.name);
   private readonly AUTOCOMPLETE_LIMIT = 10;
   private readonly CACHE_TTL_MS = 300000; // 5 minutes
-  private autocompleteCache: Map<string, { results: AutocompleteResult[]; timestamp: number }> =
-    new Map();
+  private readonly AUTOCOMPLETE_CACHE_MAX_SIZE = 1000;
+  private autocompleteCache: LRUCache<string, AutocompleteResult[]>;
 
   constructor(
     @InjectRepository(Course)
     private readonly courseRepository: Repository<Course>,
     private readonly elasticsearch: NestElasticsearchService,
     @Optional() @Inject(CACHE_MANAGER) private readonly cacheManager?: Cache,
-  ) {}
+  ) {
+    this.autocompleteCache = new LRUCache<string, AutocompleteResult[]>({
+      max: this.AUTOCOMPLETE_CACHE_MAX_SIZE,
+      ttl: this.CACHE_TTL_MS,
+    });
+  }
 
   async search(
     query: string,
@@ -102,7 +108,7 @@ export class SearchService {
     if (!query || query.length < 2) return [];
 
     const cached = this.autocompleteCache.get(query);
-    if (cached && Date.now() - cached.timestamp < this.CACHE_TTL_MS) return cached.results;
+    if (cached) return cached;
 
     try {
       const courses = await this.courseRepository
@@ -119,7 +125,7 @@ export class SearchService {
         metadata: { courseId: course.id },
       }));
 
-      this.autocompleteCache.set(query, { results, timestamp: Date.now() });
+      this.autocompleteCache.set(query, results);
       return results;
     } catch (err) {
       this.logger.error(`Autocomplete failed: ${(err as Error).message}`);