Fix/Finish initial song search implementation

.vscode/extensions.json

@@ -3,6 +3,9 @@
     "dbaeumer.vscode-eslint",
     "esbenp.prettier-vscode",
     "unifiedjs.vscode-mdx",
-    "orta.vscode-jest"
+    "orta.vscode-jest",
+    "bradlc.vscode-tailwindcss",
+    "fill-labs.dependi",
+    "gruntfuggly.todo-tree"
   ]
 }

.vscode/settings.json

@@ -12,5 +12,9 @@
   "eslint.format.enable": true,
   "editor.codeActionsOnSave": {
     "source.fixAll.eslint": "always"
+  },
+  "files.associations": {
+    ".css": "tailwindcss",
+    "*.scss": "tailwindcss"
   }
 }

apps/backend/src/song/song.controller.spec.ts

@@ -26,16 +26,14 @@ import { SongService } from './song.service';
 
 const mockSongService = {
   getSongByPage: jest.fn(),
-  searchSongs: jest.fn(),
+  querySongs: jest.fn(),
   getSong: jest.fn(),
   getSongEdit: jest.fn(),
   patchSong: jest.fn(),
   getSongDownloadUrl: jest.fn(),
   deleteSong: jest.fn(),
   uploadSong: jest.fn(),
   getRandomSongs: jest.fn(),
-  getRecentSongs: jest.fn(),
-  getSongsByCategory: jest.fn(),
   getSongsForTimespan: jest.fn(),
   getSongsBeforeTimespan: jest.fn(),
   getCategories: jest.fn(),
@@ -97,13 +95,13 @@ describe('SongController', () => {
       const query: SongListQueryDTO = { page: 1, limit: 10, q: 'test search' };
       const songList: SongPreviewDto[] = [];
 
-      mockSongService.searchSongs.mockResolvedValueOnce(songList);
+      mockSongService.querySongs.mockResolvedValueOnce(songList);
 
       const result = await songController.getSongList(query);
 
       expect(result).toBeInstanceOf(PageDto);
       expect(result.content).toEqual(songList);
-      expect(songService.searchSongs).toHaveBeenCalled();
+      expect(songService.querySongs).toHaveBeenCalled();
     });
 
     it('should handle random sort', async () => {
@@ -161,13 +159,22 @@ describe('SongController', () => {
       };
       const songList: SongPreviewDto[] = [];
 
-      mockSongService.getRecentSongs.mockResolvedValueOnce(songList);
+      mockSongService.querySongs.mockResolvedValueOnce(songList);
 
       const result = await songController.getSongList(query);
 
       expect(result).toBeInstanceOf(PageDto);
       expect(result.content).toEqual(songList);
-      expect(songService.getRecentSongs).toHaveBeenCalledWith(1, 10);
+      expect(songService.querySongs).toHaveBeenCalledWith(
+        expect.objectContaining({
+          page: 1,
+          limit: 10,
+          sort: 'createdAt',
+          order: true,
+        }),
+        undefined,
+        undefined,
+      );
     });
 
     it('should handle recent sort with category', async () => {
@@ -179,13 +186,22 @@ describe('SongController', () => {
       };
       const songList: SongPreviewDto[] = [];
 
-      mockSongService.getSongsByCategory.mockResolvedValueOnce(songList);
+      mockSongService.querySongs.mockResolvedValueOnce(songList);
 
       const result = await songController.getSongList(query);
 
       expect(result).toBeInstanceOf(PageDto);
       expect(result.content).toEqual(songList);
-      expect(songService.getSongsByCategory).toHaveBeenCalledWith('pop', 1, 10);
+      expect(songService.querySongs).toHaveBeenCalledWith(
+        expect.objectContaining({
+          page: 1,
+          limit: 10,
+          sort: 'createdAt',
+          order: true,
+        }),
+        undefined,
+        'pop',
+      );
     });
 
     it('should handle category filter', async () => {
@@ -196,16 +212,18 @@ describe('SongController', () => {
       };
       const songList: SongPreviewDto[] = [];
 
-      mockSongService.getSongsByCategory.mockResolvedValueOnce(songList);
+      mockSongService.querySongs.mockResolvedValueOnce(songList);
 
       const result = await songController.getSongList(query);
 
       expect(result).toBeInstanceOf(PageDto);
       expect(result.content).toEqual(songList);
-      expect(songService.getSongsByCategory).toHaveBeenCalledWith(
-        'rock',
+      expect(songService.getSongsBySortAndCategory).toHaveBeenCalledWith(
+        'createdAt',
+        true,
         1,
         10,
+        'rock',
       );
     });
 

apps/backend/src/song/song.controller.ts

@@ -77,7 +77,7 @@ export class SongController {
 
       **Query Parameters:**
       - \`q\`: Search string to filter songs by title or description (optional)
-      - \`sort\`: Sort songs by criteria (recent, random, play-count, title, duration, note-count)
+      - \`sort\`: Sort songs by criteria (recent, random, playCount, title, duration, noteCount)
       - \`order\`: Sort order (asc, desc) - only applies if sort is not random
       - \`category\`: Filter by category - if left empty, returns songs in any category
       - \`uploader\`: Filter by uploader username - if provided, will only return songs uploaded by that user
@@ -100,33 +100,6 @@ export class SongController {
   public async getSongList(
     @Query() query: SongListQueryDTO,
   ): Promise<PageDto<SongPreviewDto>> {
-    // Handle search query
-    if (query.q) {
-      const sortFieldMap = new Map([
-        [SongSortType.RECENT, 'createdAt'],
-        [SongSortType.PLAY_COUNT, 'playCount'],
-        [SongSortType.TITLE, 'title'],
-        [SongSortType.DURATION, 'duration'],
-        [SongSortType.NOTE_COUNT, 'noteCount'],
-      ]);
-
-      const sortField = sortFieldMap.get(query.sort) ?? 'createdAt';
-
-      const pageQuery = new PageQueryDTO({
-        page: query.page,
-        limit: query.limit,
-        sort: sortField,
-        order: query.order === 'desc' ? false : true,
-      });
-      const data = await this.songService.searchSongs(pageQuery, query.q);
-      return new PageDto<SongPreviewDto>({
-        content: data,
-        page: query.page,
-        limit: query.limit,
-        total: data.length,
-      });
-    }
-
     // Handle random sort
     if (query.sort === SongSortType.RANDOM) {
       if (query.limit && (query.limit < 1 || query.limit > 10)) {
@@ -147,67 +120,33 @@ export class SongController {
       });
     }
 
-    // Handle recent sort
-    if (query.sort === SongSortType.RECENT) {
-      // If category is provided, use getSongsByCategory (which also sorts by recent)
-      if (query.category) {
-        const data = await this.songService.getSongsByCategory(
-          query.category,
-          query.page,
-          query.limit,
-        );
-        return new PageDto<SongPreviewDto>({
-          content: data,
-          page: query.page,
-          limit: query.limit,
-          total: data.length,
-        });
-      }
-
-      const data = await this.songService.getRecentSongs(
-        query.page,
-        query.limit,
-      );
-      return new PageDto<SongPreviewDto>({
-        content: data,
-        page: query.page,
-        limit: query.limit,
-        total: data.length,
-      });
-    }
-
-    // Handle category filter
-    if (query.category) {
-      const data = await this.songService.getSongsByCategory(
-        query.category,
-        query.page,
-        query.limit,
-      );
-      return new PageDto<SongPreviewDto>({
-        content: data,
-        page: query.page,
-        limit: query.limit,
-        total: data.length,
-      });
-    }
-
-    // Default: get songs with standard pagination
-    const sortFieldMap = new Map([
+    // Map sort types to MongoDB field paths
+    const sortFieldMap = new Map<SongSortType, string>([
+      [SongSortType.RECENT, 'createdAt'],
       [SongSortType.PLAY_COUNT, 'playCount'],
       [SongSortType.TITLE, 'title'],
-      [SongSortType.DURATION, 'duration'],
-      [SongSortType.NOTE_COUNT, 'noteCount'],
+      [SongSortType.DURATION, 'stats.duration'],
+      [SongSortType.NOTE_COUNT, 'stats.noteCount'],
     ]);
 
     const sortField = sortFieldMap.get(query.sort) ?? 'createdAt';
+    const isDescending = query.order ? query.order === 'desc' : true;
 
+    // Build PageQueryDTO with the sort field
     const pageQuery = new PageQueryDTO({
       page: query.page,
       limit: query.limit,
       sort: sortField,
-      order: query.order === 'desc' ? false : true,
+      order: isDescending,
     });
-    const data = await this.songService.getSongByPage(pageQuery);
+
+    // Query songs with optional search and category filters
+    const data = await this.songService.querySongs(
+      pageQuery,
+      query.q,
+      query.category,
+    );
+
     return new PageDto<SongPreviewDto>({
       content: data,
       page: query.page,
@@ -323,7 +262,7 @@ export class SongController {
     @Query() query: PageQueryDTO,
     @Query('q') q: string,
   ): Promise<PageDto<SongPreviewDto>> {
-    const data = await this.songService.searchSongs(query, q ?? '');
+    const data = await this.songService.querySongs(query, q ?? '');
     return new PageDto<SongPreviewDto>({
       content: data,
       page: query.page,

apps/backend/src/song/song.service.spec.ts

@@ -1028,11 +1028,15 @@ describe('SongService', () => {
     });
   });
 
-  describe('getSongsByCategory', () => {
-    it('should return a list of songs by category', async () => {
-      const category = 'test-category';
-      const page = 1;
-      const limit = 10;
+  describe('querySongs', () => {
+    it('should return songs sorted by field with optional category filter', async () => {
+      const query = {
+        page: 1,
+        limit: 10,
+        sort: 'stats.duration',
+        order: false,
+      };
+      const category = 'pop';
       const songList: SongWithUser[] = [];
 
       const mockFind = {
@@ -1045,20 +1049,22 @@ describe('SongService', () => {
 
       jest.spyOn(songModel, 'find').mockReturnValue(mockFind as any);
 
-      const result = await service.getSongsByCategory(category, page, limit);
+      const result = await service.querySongs(query, undefined, category);
 
       expect(result).toEqual(
         songList.map((song) => SongPreviewDto.fromSongDocumentWithUser(song)),
       );
 
       expect(songModel.find).toHaveBeenCalledWith({
-        category,
         visibility: 'public',
+        category,
       });
 
-      expect(mockFind.sort).toHaveBeenCalledWith({ createdAt: -1 });
-      expect(mockFind.skip).toHaveBeenCalledWith(page * limit - limit);
-      expect(mockFind.limit).toHaveBeenCalledWith(limit);
+      expect(mockFind.sort).toHaveBeenCalledWith({ 'stats.duration': 1 });
+      expect(mockFind.skip).toHaveBeenCalledWith(
+        (query.limit as number) * ((query.page as number) - 1),
+      );
+      expect(mockFind.limit).toHaveBeenCalledWith(query.limit);
 
       expect(mockFind.populate).toHaveBeenCalledWith(
         'uploader',
@@ -1067,12 +1073,14 @@ describe('SongService', () => {
 
       expect(mockFind.exec).toHaveBeenCalled();
     });
-  });
 
-  describe('getRecentSongs', () => {
-    it('should return recent songs', async () => {
-      const page = 1;
-      const limit = 10;
+    it('should work without category filter', async () => {
+      const query = {
+        page: 1,
+        limit: 10,
+        sort: 'createdAt',
+        order: true,
+      };
       const songList: SongWithUser[] = [];
 
       const mockFind = {
@@ -1085,16 +1093,50 @@ describe('SongService', () => {
 
       jest.spyOn(songModel, 'find').mockReturnValue(mockFind as any);
 
-      const result = await service.getRecentSongs(page, limit);
+      const result = await service.querySongs(query);
 
+      expect(songModel.find).toHaveBeenCalledWith({ visibility: 'public' });
+      expect(mockFind.sort).toHaveBeenCalledWith({ createdAt: -1 });
       expect(result).toEqual(
         songList.map((song) => SongPreviewDto.fromSongDocumentWithUser(song)),
       );
+    });
 
-      expect(songModel.find).toHaveBeenCalledWith({ visibility: 'public' });
-      expect(mockFind.sort).toHaveBeenCalledWith({ createdAt: -1 });
-      expect(mockFind.skip).toHaveBeenCalledWith(page * limit - limit);
-      expect(mockFind.limit).toHaveBeenCalledWith(limit);
+    it('should search with text query and filters', async () => {
+      const query = {
+        page: 1,
+        limit: 10,
+        sort: 'playCount',
+        order: false,
+      };
+      const searchTerm = 'test song';
+      const category = 'rock';
+      const songList: SongWithUser[] = [];
+
+      const mockFind = {
+        sort: jest.fn().mockReturnThis(),
+        skip: jest.fn().mockReturnThis(),
+        limit: jest.fn().mockReturnThis(),
+        populate: jest.fn().mockReturnThis(),
+        exec: jest.fn().mockResolvedValue(songList),
+      };
+
+      jest.spyOn(songModel, 'find').mockReturnValue(mockFind as any);
+
+      const result = await service.querySongs(query, searchTerm, category);
+
+      expect(result).toEqual(
+        songList.map((song) => SongPreviewDto.fromSongDocumentWithUser(song)),
+      );
+
+      expect(songModel.find).toHaveBeenCalledWith(
+        expect.objectContaining({
+          visibility: 'public',
+          category,
+        }),
+      );
+
+      expect(mockFind.sort).toHaveBeenCalledWith({ playCount: 1 });
     });
   });