Updated resolvers (Closes #53)

server/src/graphQL/resolvers.ts

@@ -1,64 +1,95 @@
-import { start } from 'node:repl';
-import { MOCK_ALBUMS } from './mockAlbums.js';
+import { pool } from '../database/connection.js';
 
 export const resolvers = {
   Query: {
-    albums: (_: unknown, args: { search?: string; genre?: string; decade?: number; first?: number, after?: string }) => {
-      let filtered = [...MOCK_ALBUMS];
+    albums: async (_: unknown, args: { search?: string; genre?: string; decade?: number; first?: number }) => {
+      let sql = `
+        SELECT 
+          id, 
+          title, 
+          artist, 
+          release_year AS "releaseYear", 
+          genre, 
+          cover_url AS "coverUrl"
+        FROM albums
+        WHERE 1=1
+      `;
+      const queryParams: (string | number)[] = [];
+
 
-      // Søkefilter på tittel eller artist
       if (args.search) {
-        const query = args.search.toLowerCase();
-        filtered = filtered.filter(
-          (album) =>
-            album.title.toLowerCase().includes(query) ||
-            album.artist.toLowerCase().includes(query)
-        );
+        queryParams.push(`%${args.search}%`);
+        sql += ` AND (LOWER(title) LIKE LOWER($${queryParams.length}) OR LOWER(artist) LIKE LOWER($${queryParams.length}))`;
       }
 
-      // Sjangerfilter
+
       if (args.genre) {
-        filtered = filtered.filter(
-          (album) => album.genre.toLowerCase() === args.genre?.toLowerCase()
-        );
+        queryParams.push(args.genre);
+        sql += ` AND LOWER(genre) = LOWER($${queryParams.length})`;
       }
 
-      // Tiår-filter (f.eks. 1970 for 70-tallet)
+
       if (args.decade) {
-        filtered = filtered.filter(
-          (album) =>
-            album.releaseYear >= args.decade! && album.releaseYear < args.decade! + 10
-        );
+        queryParams.push(args.decade);
+        sql += ` AND release_year >= $${queryParams.length} AND release_year < $${queryParams.length} + 10`;
       }
 
-      const limit = args.first ?? 8;
+      const limit = args.first || 10;
+
 
-      let startIndex = 0;
+      queryParams.push(limit + 1);
+      sql += ` ORDER BY title ASC LIMIT $${queryParams.length}`;
 
-      if (args.after) {
-        const cursorIndex = filtered.findIndex(
-          (album) => album.id === args.after
-        );
+      const { rows } = await pool.query(sql, queryParams);
 
-        if (cursorIndex !== -1) {
-          startIndex = cursorIndex + 1;
-        }
-      }
-
-      const sliced = filtered.slice(startIndex, startIndex + limit);
+      const hasNextPage = rows.length > limit;
+      const sliced = hasNextPage ? rows.slice(0, limit) : rows;
 
       return {
         edges: sliced,
-        totalCount: filtered.length,
         pageInfo: {
           endCursor: sliced.length > 0 ? sliced[sliced.length - 1].id : null,
-          hasNextPage: startIndex + sliced.length < filtered.length,
+          hasNextPage,
         },
       };
     },
 
-    album: (_: unknown, args: { id: string }) => {
-      return MOCK_ALBUMS.find((album) => album.id === args.id) || null;
+    album: async (_: unknown, args: { id: string }) => {
+      const albumSql = `
+        SELECT 
+          id, 
+          title, 
+          artist, 
+          release_year AS "releaseYear", 
+          genre, 
+          cover_url AS "coverUrl"
+        FROM albums
+        WHERE id = $1
+      `;
+      const { rows: albumRows } = await pool.query(albumSql, [args.id]);
+
+      if (albumRows.length === 0) {
+        return null;
+      }
+
+      const album = albumRows[0];
+
+
+      const tracksSql = `
+        SELECT 
+          id, 
+          title, 
+          duration 
+        FROM tracks 
+        WHERE album_id = $1
+        ORDER BY track_number ASC
+      `;
+      const { rows: trackRows } = await pool.query(tracksSql, [args.id]);
+
+      return {
+        ...album,
+        tracks: trackRows,
+      };
     },
   },
 };