Merge pull request #48 from justinhartman/develop

justinhartman · web-flow · commit e9f3e0a04b0b · 2025-08-26T01:18:25.000+02:00
Merge develop into main
diff --git a/controllers/appController.spec.ts b/controllers/appController.spec.ts
@@ -38,8 +38,7 @@ describe('controllers/appController', () => {
     jest.clearAllMocks();
     (getSeriesDetail as jest.Mock).mockResolvedValue({
       totalSeasons: 1,
-      totalEpisodes: 1,
-      seasons: [{ season: 1, episodes: [{ episode: 1, title: 'E1' }] }],
+      currentSeason: { season: 1, episodes: [{ episode: 1, title: 'E1' }] },
     });
   });
 
@@ -126,7 +125,7 @@ describe('controllers/appController', () => {
       { $set: { type: 'series', lastSeason: 1, lastEpisode: 2 } },
       { upsert: true }
     );
-    expect(getSeriesDetail).toHaveBeenCalledWith('tt');
+    expect(getSeriesDetail).toHaveBeenCalledWith('tt', 1);
     expect(res.render).toHaveBeenCalledWith('view', expect.objectContaining({
       season: '1',
       episode: '2',
diff --git a/controllers/appController.ts b/controllers/appController.ts
@@ -161,7 +161,7 @@ const appController = {
       const iframeSrc = `https://${appConfig.VIDSRC_DOMAIN}/embed/tv?imdb=${id}&season=${season}&episode=${episode}`;
       const canonical = `${res.locals.APP_URL}/view/${id}/${type}/${season}/${episode}`;
       const data = await fetchOmdbData(id, false);
-      const seriesDetail = await getSeriesDetail(id);
+      const seriesDetail = await getSeriesDetail(id, Number(season));
       return res.render('view', {
         data,
         iframeSrc,
diff --git a/helpers/appHelper.spec.ts b/helpers/appHelper.spec.ts
@@ -25,10 +25,15 @@ import appConfig from '../config/app';
 import * as helper from './appHelper';
 
 describe('helpers/appHelper', () => {
-  afterEach(() => {
+  beforeEach(() => {
+    helper.__clearCaches();
     jest.clearAllMocks();
   });
 
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
   test('fetchOmdbData returns empty object when query missing', async () => {
     const result = await helper.fetchOmdbData('', true);
     expect(result).toEqual({});
@@ -63,6 +68,19 @@ describe('helpers/appHelper', () => {
     expect(data).toEqual({});
   });
 
+  test('fetchOmdbData caches results and expires', async () => {
+    jest.useFakeTimers();
+    (http.request as jest.Mock).mockResolvedValue({ data: { Title: 'Test' } });
+    await helper.fetchOmdbData('tt123', false, 'movie');
+    await helper.fetchOmdbData('tt123', false, 'movie');
+    expect(http.request).toHaveBeenCalledTimes(1);
+    jest.setSystemTime(Date.now() + helper.CACHE_TTL_MS + 1);
+    (http.request as jest.Mock).mockResolvedValue({ data: { Title: 'Test2' } });
+    await helper.fetchOmdbData('tt123', false, 'movie');
+    expect(http.request).toHaveBeenCalledTimes(2);
+    jest.useRealTimers();
+  });
+
   test('fetchAndUpdatePosters validates poster availability', async () => {
     const shows: any[] = [
       { imdb_id: '1' },
@@ -95,36 +113,63 @@ describe('helpers/appHelper', () => {
   test('getSeriesDetail retrieves seasons and episodes', async () => {
     (http.request as jest.Mock)
       .mockResolvedValueOnce({ data: { totalSeasons: '2', Episodes: [{ Episode: '1', Title: 'E1' }] } })
-      .mockResolvedValueOnce({ data: { Episodes: [{ Episode: '1', Title: 'E2' }, { Episode: '2', Title: 'E3' }] } });
-    const detail = await helper.getSeriesDetail('tt1');
+      .mockResolvedValueOnce({ data: { totalSeasons: '2', Episodes: [{ Episode: '1', Title: 'E2' }, { Episode: '2', Title: 'E3' }] } });
+    const detail = await helper.getSeriesDetail('tt1', 1);
     expect(http.request).toHaveBeenCalledTimes(2);
     expect(detail.totalSeasons).toBe(2);
-    expect(detail.totalEpisodes).toBe(3);
-    expect(detail.seasons[1].episodes[1].title).toBe('E3');
+    expect(detail.currentSeason.episodes[0].title).toBe('E1');
+    expect(detail.nextSeason?.episodes[1].title).toBe('E3');
   });
 
   test('getSeriesDetail handles missing titles and episode arrays', async () => {
     (http.request as jest.Mock)
       .mockResolvedValueOnce({ data: { totalSeasons: '2', Episodes: [{ Episode: '1', Title: 'N/A' }] } })
-      .mockResolvedValueOnce({ data: { Episodes: 'N/A' } });
-    const detail = await helper.getSeriesDetail('tt2');
-    expect(detail.seasons[0].episodes[0].title).toBeUndefined();
-    expect(detail.seasons[1].episodes).toEqual([]);
+      .mockResolvedValueOnce({ data: { totalSeasons: '2', Episodes: 'N/A' } });
+    const detail = await helper.getSeriesDetail('tt2', 1);
+    expect(detail.currentSeason.episodes[0].title).toBeUndefined();
+    expect(detail.nextSeason?.episodes).toEqual([]);
   });
 
   test('getSeriesDetail defaults when totalSeasons missing', async () => {
     (http.request as jest.Mock).mockResolvedValueOnce({ data: {} });
-    const detail = await helper.getSeriesDetail('tt3');
+    const detail = await helper.getSeriesDetail('tt3', 1);
     expect(detail.totalSeasons).toBe(0);
-    expect(detail.seasons).toEqual([]);
+    expect(detail.currentSeason.episodes).toEqual([]);
   });
 
   test('getSeriesDetail returns empty when id missing', async () => {
-    const detail = await helper.getSeriesDetail('');
-    expect(detail).toEqual({ totalSeasons: 0, totalEpisodes: 0, seasons: [] });
+    const detail = await helper.getSeriesDetail('', 1);
+    expect(detail).toEqual({ totalSeasons: 0, currentSeason: { season: 0, episodes: [] } });
     expect(http.request).not.toHaveBeenCalled();
   });
 
+  test('getSeriesDetail caches seasons and expires', async () => {
+    jest.useFakeTimers();
+    (http.request as jest.Mock)
+      .mockResolvedValueOnce({ data: { totalSeasons: '2', Episodes: [{ Episode: '1', Title: 'E1' }] } })
+      .mockResolvedValueOnce({ data: { totalSeasons: '2', Episodes: [{ Episode: '1', Title: 'E2' }] } });
+    await helper.getSeriesDetail('tt1', 1);
+    await helper.getSeriesDetail('tt1', 1);
+    expect(http.request).toHaveBeenCalledTimes(2);
+    jest.setSystemTime(Date.now() + helper.CACHE_TTL_MS + 1);
+    (http.request as jest.Mock)
+      .mockResolvedValueOnce({ data: { totalSeasons: '2', Episodes: [{ Episode: '1', Title: 'E1' }] } })
+      .mockResolvedValueOnce({ data: { totalSeasons: '2', Episodes: [{ Episode: '1', Title: 'E2' }] } });
+    await helper.getSeriesDetail('tt1', 1);
+    expect(http.request).toHaveBeenCalledTimes(4);
+    jest.useRealTimers();
+  });
+
+  test('getSeriesDetail caches neighbour seasons', async () => {
+    (http.request as jest.Mock)
+      .mockResolvedValueOnce({ data: { totalSeasons: '3', Episodes: [{ Episode: '1', Title: 'A' }] } })
+      .mockResolvedValueOnce({ data: { totalSeasons: '3', Episodes: [{ Episode: '1', Title: 'B' }] } })
+      .mockResolvedValueOnce({ data: { totalSeasons: '3', Episodes: [{ Episode: '1', Title: 'C' }] } });
+    await helper.getSeriesDetail('tt1', 1);
+    await helper.getSeriesDetail('tt1', 2);
+    expect(http.request).toHaveBeenCalledTimes(3);
+  });
+
   test('useAuth is false when no mongo uri', () => {
     expect(helper.useAuth).toBe(false);
   });
diff --git a/helpers/appHelper.ts b/helpers/appHelper.ts
@@ -13,6 +13,19 @@ import http from './httpClient';
 import appConfig from '../config/app';
 import type { EpisodeInfo, SeasonDetail, SeriesDetail } from '../types/interfaces';
 
+/**
+ * TTL for cached OMDb responses in milliseconds (5 minutes).
+ */
+export const CACHE_TTL_MS = 1000 * 60 * 5;
+
+const omdbCache = new Map<string, { data: any; expires: number }>();
+const seriesCache = new Map<string, { data: any; expires: number }>();
+
+export const __clearCaches = (): void => {
+  omdbCache.clear();
+  seriesCache.clear();
+};
+
 /**
  * Constructs parameters object for OMDB API requests.
  * @param query - Search term for title search or IMDB ID for specific item lookup
@@ -44,6 +57,12 @@ export const fetchOmdbData = async (
   type = ''
 ): Promise<any> => {
   if (!query) return {};
+  const key = `${query}:${search}:${type}`;
+  const now = Date.now();
+  const cached = omdbCache.get(key);
+  if (cached && cached.expires > now) {
+    return cached.data;
+  }
   const params = constructOmdbParams(query, search, type);
   const options: AxiosRequestConfig = {
     method: 'GET',
@@ -54,7 +73,9 @@ export const fetchOmdbData = async (
     },
   };
   const response = await http.request(options);
-  return response.data || {};
+  const data = response.data || {};
+  omdbCache.set(key, { data, expires: now + CACHE_TTL_MS });
+  return data;
 };
 
 /**
@@ -85,43 +106,69 @@ export const fetchAndUpdatePosters = async (show: any[]): Promise<void> => {
 };
 
 /**
- * Retrieves detailed information for a series including seasons and episodes.
+ * Retrieves detailed information for a specific season of a series.
+ * Also optionally fetches neighbouring seasons for navigation.
  * @param id - IMDB ID of the series
- * @returns {Promise<SeriesDetail>} Object containing total seasons, total episodes and per-season breakdown
+ * @param season - Season number to retrieve
+ * @returns {Promise<SeriesDetail>} Object containing total seasons and cached season details
  */
-export const getSeriesDetail = async (id: string): Promise<SeriesDetail> => {
-  if (!id) return { totalSeasons: 0, totalEpisodes: 0, seasons: [] };
+export const getSeriesDetail = async (id: string, season: number): Promise<SeriesDetail> => {
+  if (!id) return { totalSeasons: 0, currentSeason: { season: 0, episodes: [] } };
 
-  const buildOptions = (season: number): AxiosRequestConfig => ({
+  const buildOptions = (s: number): AxiosRequestConfig => ({
     method: 'GET',
     url: appConfig.OMDB_API_URL,
     params: {
       apikey: appConfig.OMDB_API_KEY,
       i: id,
-      Season: season,
+      Season: s,
     },
     headers: { 'Content-Type': 'application/json' },
   });
 
-  const firstResponse = await http.request(buildOptions(1));
-  const totalSeasons = Number(firstResponse.data.totalSeasons || 0);
-
-  const seasons: SeasonDetail[] = [];
-  let totalEpisodes = 0;
-
-  for (let s = 1; s <= totalSeasons; s++) {
-    const seasonData = s === 1 ? firstResponse.data : (await http.request(buildOptions(s))).data;
+  const fetchSeason = async (s: number) => {
+    const key = `${id}:${s}`;
+    const now = Date.now();
+    const cached = seriesCache.get(key);
+    if (cached && cached.expires > now) return cached.data;
+    const response = await http.request(buildOptions(s));
+    const seasonData = response.data || {};
     const episodes: EpisodeInfo[] = Array.isArray(seasonData.Episodes)
       ? seasonData.Episodes.map((ep: any) => ({
           episode: Number(ep.Episode),
           title: ep.Title !== 'N/A' ? ep.Title : undefined,
         }))
       : [];
-    seasons.push({ season: s, episodes });
-    totalEpisodes += episodes.length;
+    const data = {
+      season: s,
+      episodes,
+      totalSeasons: Number(seasonData.totalSeasons || 0),
+    };
+    seriesCache.set(key, { data, expires: now + CACHE_TTL_MS });
+    return data;
+  };
+
+  const current = await fetchSeason(season);
+  const totalSeasons = current.totalSeasons;
+  let prevSeason: SeasonDetail | undefined;
+  let nextSeason: SeasonDetail | undefined;
+
+  if (season > 1) {
+    const prev = await fetchSeason(season - 1);
+    prevSeason = { season: prev.season, episodes: prev.episodes };
   }
 
-  return { totalSeasons, totalEpisodes, seasons };
+  if (season < totalSeasons) {
+    const next = await fetchSeason(season + 1);
+    nextSeason = { season: next.season, episodes: next.episodes };
+  }
+
+  return {
+    totalSeasons,
+    currentSeason: { season: current.season, episodes: current.episodes },
+    ...(prevSeason && { prevSeason }),
+    ...(nextSeason && { nextSeason }),
+  };
 };
 
 /**
diff --git a/helpers/cache.spec.ts b/helpers/cache.spec.ts
@@ -1,7 +1,14 @@
 import { getLatest, setLatest, invalidateLatest } from './cache';
 
 describe('helpers/cache', () => {
-  afterEach(() => invalidateLatest());
+  afterEach(() => {
+    invalidateLatest();
+    jest.useRealTimers();
+  });
+
+  test('cache miss when empty', () => {
+    expect(getLatest()).toBeUndefined();
+  });
 
   test('stores and retrieves latest content', () => {
     const data = { movies: [1], series: [2] } as any;
@@ -14,4 +21,12 @@ describe('helpers/cache', () => {
     invalidateLatest();
     expect(getLatest()).toBeUndefined();
   });
+
+  test('cache entry expires after TTL', () => {
+    jest.useFakeTimers();
+    const data = { movies: [1], series: [2] } as any;
+    setLatest(data);
+    jest.setSystemTime(Date.now() + 60 * 60 * 24 * 1000 + 1);
+    expect(getLatest()).toBeUndefined();
+  });
 });
diff --git a/package.json b/package.json
@@ -50,6 +50,8 @@
     "passport-local": "^1.0.0"
   },
   "devDependencies": {
+    "@jest/globals": "^30.0.5",
+    "@types/body-parser": "^1.19.6",
     "@types/ejs": "^3.1.5",
     "@types/express": "^5.0.3",
     "@types/jest": "^30.0.0",
@@ -62,6 +64,7 @@
     "grunt-git": "^1.1.1",
     "jest": "^30.0.5",
     "jest-junit": "^16.0.0",
+    "jest-util": "^30.0.5",
     "migrate-mongo": "^11.0.0",
     "supertest": "^7.0.0",
     "ts-jest": "^29.4.1",
diff --git a/types/interfaces.d.ts b/types/interfaces.d.ts
@@ -107,13 +107,15 @@ export interface SeasonDetail {
  * @interface SeriesDetail
  * @description Interface representing complete details about a TV series.
  * @property {number} totalSeasons - Total number of seasons in the series
- * @property {number} totalEpisodes - Total number of episodes across all seasons
- * @property {SeasonDetail[]} seasons - Array containing details of each season
+ * @property {SeasonDetail} currentSeason - Details for the currently viewed season
+ * @property {SeasonDetail} [prevSeason] - Optional details for the previous season
+ * @property {SeasonDetail} [nextSeason] - Optional details for the next season
  */
 export interface SeriesDetail {
   totalSeasons: number;
-  totalEpisodes: number;
-  seasons: SeasonDetail[];
+  currentSeason: SeasonDetail;
+  prevSeason?: SeasonDetail;
+  nextSeason?: SeasonDetail;
 }
 
 /**
diff --git a/views/partials/series-buttons.ejs b/views/partials/series-buttons.ejs
@@ -1,27 +1,24 @@
 <%
 const seasonNum = Number(season);
 const episodeNum = Number(episode);
-const totalSeasons = seriesDetail?.totalSeasons || 0;
-const currentSeason = seriesDetail?.seasons?.find(s => s.season === seasonNum) || { episodes: [] };
+const currentSeason = seriesDetail?.currentSeason || { episodes: [] };
 const maxEpisodes = currentSeason.episodes.length;
 let prevDisabled = false;
 let nextDisabled = false;
 let prevLink = `${APP_URL}/view/${id}/${type}/${seasonNum}/${episodeNum - 1}`;
 let nextLink = `${APP_URL}/view/${id}/${type}/${seasonNum}/${episodeNum + 1}`;
 if (episodeNum <= 1) {
-  if (seasonNum > 1) {
-    const prevSeason = seasonNum - 1;
-    const prevSeasonEpisodes = seriesDetail.seasons.find(s => s.season === prevSeason)?.episodes.length || 0;
-    prevLink = `${APP_URL}/view/${id}/${type}/${prevSeason}/${prevSeasonEpisodes}`;
+  if (seriesDetail?.prevSeason) {
+    const prevSeasonEpisodes = seriesDetail.prevSeason.episodes.length || 0;
+    prevLink = `${APP_URL}/view/${id}/${type}/${seriesDetail.prevSeason.season}/${prevSeasonEpisodes}`;
   } else {
     prevDisabled = true;
     prevLink = '#';
   }
 }
 if (episodeNum >= maxEpisodes) {
-  if (seasonNum < totalSeasons) {
-    const nextSeason = seasonNum + 1;
-    nextLink = `${APP_URL}/view/${id}/${type}/${nextSeason}/1`;
+  if (seriesDetail?.nextSeason) {
+    nextLink = `${APP_URL}/view/${id}/${type}/${seriesDetail.nextSeason.season}/1`;
   } else {
     nextDisabled = true;
     nextLink = '#';
diff --git a/views/view.ejs b/views/view.ejs
@@ -59,7 +59,7 @@
         </div>
         <div class="series-episodes d-flex flex-wrap flex-md-column mt-2 mt-md-0">
             <%- include('./partials/series-buttons.ejs') -%>
-            <% const currentSeason = seriesDetail.seasons.find(se => se.season === Number(season)) || { episodes: [] }; %>
+            <% const currentSeason = seriesDetail.currentSeason || { episodes: [] }; %>
             <% currentSeason.episodes.forEach(ep => { %>
                 <a href="<%= `${APP_URL}/view/${id}/${type}/${season}/${ep.episode}` %>" class="btn btn-outline-info btn-sm text-start m-1 <%= Number(episode) === ep.episode ? 'active' : '' %>"><%= ep.episode %>. <%= ep.title || `Episode ${ep.episode}` %></a>
             <% }) %>
diff --git a/yarn.lock b/yarn.lock
