fix(server): network/companies pages now return correct data

Author: ADRFranklin

server/src/api/routes/movie.ts

@@ -40,13 +40,24 @@ const lookupByIdMinified = async (ctx: Context) => {
 };
 
 const getMovieDiscovery = async (ctx: Context) => {
-  const body = ctx.request.body as any;
+  const service = getFromContainer(MovieService);
+  const mapper = getFromContainer(MovieMapper);
 
-  const page = body.page ? body.page : 1;
-  const { params } = body;
+  const { page } = (ctx.request.body as any) || 1;
+  const { with_companies } = ctx.query;
+
+  const results = await service.getDiscover({
+    page,
+    limit: 30,
+    withCompanies: with_companies
+      ? parseInt(with_companies as string)
+      : undefined,
+  });
 
   ctx.status = StatusCodes.OK;
-  ctx.body = await discoverMovie(page, params);
+  ctx.body = {
+    results: results.map((movie) => mapper.toResponse(movie)),
+  };
 };
 
 const getCompanyById = async (ctx: Context) => {

server/src/api/routes/show.ts

@@ -3,7 +3,9 @@ import { StatusCodes } from 'http-status-codes';
 import { Context } from 'koa';
 
 import { getFromContainer } from '@/infrastructure/container/container';
+import { NetworkMapper } from '@/resources/network/mapper';
 import { ShowMapper } from '@/resources/show/mapper';
+import { NetworkService } from '@/services/network/network-service';
 import { ShowService } from '@/services/show/show-service';
 import { discoverSeries, network } from '@/services/tmdb/show';
 
@@ -38,18 +40,38 @@ const lookupByIdMinified = async (ctx: Context) => {
 };
 
 const discoverSeriesData = async (ctx: Context) => {
-  const body = ctx.request.body as any;
+  const service = getFromContainer(ShowService);
+  const mapper = getFromContainer(ShowMapper);
 
-  const page = body.page ? body.page : 1;
-  const { params } = body;
+  const { page } = (ctx.request.body as any) || 1;
+  const { with_networks } = ctx.query;
+
+  const results = await service.getDiscover({
+    page,
+    limit: 30,
+    filterByNetworkId: with_networks
+      ? parseInt(with_networks as string)
+      : undefined,
+  });
 
   ctx.status = StatusCodes.OK;
-  ctx.body = await discoverSeries(page, params);
+  ctx.body = {
+    results: results.map((show) => mapper.toResponse(show)),
+  };
 };
 
 const getNetworkById = async (ctx: Context) => {
+  const networkResult = await getFromContainer(
+    NetworkService,
+  ).getNetworkDetails(ctx.params.id);
+  if (networkResult.isNone()) {
+    ctx.status = StatusCodes.NOT_FOUND;
+    return;
+  }
+  const network = networkResult.unwrap();
+
   ctx.status = StatusCodes.OK;
-  ctx.body = await network(ctx.params.id);
+  ctx.body = getFromContainer(NetworkMapper).toResponse(network);
 };
 
 const route = new Router({ prefix: '/show' });

server/src/services/cache/cache-service.ts

@@ -65,23 +65,39 @@ export class CacheService {
     try {
       const results =
         await this.cacheProvider.wrap<CommonResourcesCacheResponse>(
-          'trending',
+          'resources.common',
           async () => {
-            const [movies, shows, people, networks, companies] =
-              await Promise.all([
-                this.movieService.getTrending(),
-                this.showService.getTrending(),
-                this.personService.getTrending(),
-                this.networkService.getNetworks(),
-                this.companyService.getCompanies(),
-              ]);
-
+            const [
+              movies,
+              shows,
+              people,
+              networks,
+              companies,
+              showDiscovery,
+              movieDiscovery,
+            ] = await Promise.all([
+              this.movieService.getTrending(30),
+              this.showService.getTrending(30),
+              this.personService.getTrending(30),
+              this.networkService.getNetworks(),
+              this.companyService.getCompanies(),
+              this.showService.getDiscover({
+                page: 1,
+                limit: 30,
+              }),
+              this.movieService.getDiscover({
+                page: 1,
+                limit: 30,
+              }),
+            ]);
             return {
               movies: movies.map((movie) => movie.getProps()),
               shows: shows.map((show) => show.getProps()),
               people: people.map((person) => person.getProps()),
               networks: networks.map((network) => network.getProps()),
               companies: companies.map((company) => company.getProps()),
+              showDiscovery: showDiscovery.map((show) => show.getProps()),
+              movieDiscovery: movieDiscovery.map((movie) => movie.getProps()),
             };
           },
           this.defaultCacheTTL,
@@ -96,6 +112,12 @@ export class CacheService {
         companies: results.companies.map((company) =>
           CompanyEntity.create(company),
         ),
+        showDiscovery: results.showDiscovery.map((show) =>
+          ShowEntity.create(show),
+        ),
+        movieDiscovery: results.movieDiscovery.map((movie) =>
+          MovieEntity.create(movie),
+        ),
       };
     } catch (error) {
       this.logger.error({ error }, 'Error storing trending data');
@@ -105,6 +127,8 @@ export class CacheService {
         people: [],
         networks: [],
         companies: [],
+        showDiscovery: [],
+        movieDiscovery: [],
       };
     }
   }

server/src/services/cache/types.ts

@@ -15,6 +15,8 @@ export type CommonResourcesCacheResponse = {
   people: PersonProps[];
   networks: NetworkProps[];
   companies: CompanyProps[];
+  showDiscovery: ShowProps[];
+  movieDiscovery: MovieProps[];
 };
 
 /**
@@ -26,4 +28,6 @@ export type CommonResourcesResponse = {
   people: PersonEntity[];
   networks: NetworkEntity[];
   companies: CompanyEntity[];
+  showDiscovery: ShowEntity[];
+  movieDiscovery: MovieEntity[];
 };

server/src/services/cron/jobs/discovery-scan.ts

@@ -1,6 +1,6 @@
 import { Service } from 'diod';
 
-import { AgendaCronService } from '@/services/cron/agenda-cron';
+import { AgendaCronService } from '@/services/cron/agenda-cron-service';
 import { Jobber } from '@/services/cron/job';
 import { JobCronName } from '@/services/cron/types';
 import { DiscoveryService } from '@/services/discovery/discovery';

server/src/services/movie/index.ts

@@ -4,20 +4,19 @@ import { MovieService } from '@/services/movie/movie-service';
 import { FanartMovieProvider } from '@/services/movie/provider/fanart/fanart';
 import {
   MovieArtworkProvider,
+  MovieDiscoverProvider,
   MovieProvider,
   MovieRatingProvider,
   MovieTrendingProvider,
 } from '@/services/movie/provider/provider';
-import { ServarrMovieRatingProvider } from '@/services/movie/provider/servarr/servarr';
+import { ServarrMovieProvider } from '@/services/movie/provider/servarr/servarr';
 import { TmdbMovieProvider } from '@/services/movie/provider/tmdb/tmdb';
 
 export default (builder: ContainerBuilder) => {
   builder.register(MovieProvider).use(TmdbMovieProvider).asSingleton();
   builder.register(MovieArtworkProvider).use(FanartMovieProvider).asSingleton();
-  builder
-    .register(MovieRatingProvider)
-    .use(ServarrMovieRatingProvider)
-    .asSingleton();
+  builder.register(MovieRatingProvider).use(ServarrMovieProvider).asSingleton();
   builder.register(MovieTrendingProvider).use(TmdbMovieProvider).asSingleton();
+  builder.register(MovieDiscoverProvider).use(TmdbMovieProvider).asSingleton();
   builder.registerAndUse(MovieService).asSingleton();
 };

server/src/services/movie/movie-service.ts

@@ -9,11 +9,15 @@ import { MovieRepository } from '@/resources/movie/repository';
 import { CacheProvider } from '@/services/cache/cache-provider';
 import {
   MovieArtworkProvider,
+  MovieDiscoverProvider,
   MovieProvider,
   MovieRatingProvider,
   MovieTrendingProvider,
 } from '@/services/movie/provider/provider';
-import { MovieLookupOptions } from '@/services/movie/types';
+import {
+  MovieDiscoverOptions,
+  MovieLookupOptions,
+} from '@/services/movie/types';
 
 @Service()
 export class MovieService {
@@ -36,6 +40,7 @@ export class MovieService {
     private artworkProvider: MovieArtworkProvider,
     private ratingProvider: MovieRatingProvider,
     private trendingProvider: MovieTrendingProvider,
+    private discoverProvider: MovieDiscoverProvider,
   ) {
     this.logger = logger.child({ module: 'services.movie' });
   }
@@ -128,7 +133,7 @@ export class MovieService {
    * Retrieves the trending movies.
    * @returns A Promise that resolves to an array of MovieEntity objects representing the trending movies.
    */
-  async getTrending() {
+  async getTrending(limit: number = 30): Promise<MovieEntity[]> {
     const results = await this.cacheProvider.wrap(
       `movie.trending`,
       async () => {
@@ -138,7 +143,7 @@ export class MovieService {
         }
         const trending = trendingResults.unwrap();
         const data = await Promise.all(
-          trending.map((movie) =>
+          trending.slice(0, limit).map((movie) =>
             this.getMovie(movie, {
               withArtwork: true,
               withRating: true,
@@ -174,4 +179,48 @@ export class MovieService {
     );
     return movieResult.filter((m) => m.isSome()).map((m) => m.unwrap());
   }
+
+  /**
+   * Retrieves a list of discovered movies with additional details.
+   *
+   * @param limit - The maximum number of movies to retrieve. Defaults to 30.
+   * @returns A promise that resolves to an array of MovieEntity objects representing the discovered movies.
+   */
+  async getDiscover(options?: MovieDiscoverOptions): Promise<MovieEntity[]> {
+    try {
+      const results = await this.cacheProvider.wrap(
+        `movie.discover`,
+        async () => {
+          const discovery = await this.discoverProvider.getDiscover({
+            page: options?.page || 1,
+            withCompanyId: options?.withCompanies,
+          });
+          if (discovery.isErr()) {
+            return [];
+          }
+          const data = await Promise.all(
+            discovery
+              .unwrap()
+              .slice(0, options?.limit || 30)
+              .map((movie) =>
+                this.getMovie(movie, {
+                  withArtwork: true,
+                  withRating: true,
+                  withServer: true,
+                }),
+              ),
+          );
+          return data
+            .filter((m) => m.isSome())
+            .map((m) => m.unwrap())
+            .map((m) => m.getProps());
+        },
+        this.defaultCacheTTL,
+      );
+      return results.map((m) => MovieEntity.create(m));
+    } catch (error) {
+      this.logger.error({ error }, 'Error storing discovered data');
+      return [];
+    }
+  }
 }

server/src/services/movie/provider/provider.ts

@@ -34,7 +34,18 @@ export abstract class MovieRatingProvider {
   abstract getRatings(id: number): Promise<MovieProviderRatingResponse>;
 }
 
-export type MovieTrendingReponse = Result<number[], ExceptionBase>;
+export type MovieTrendingResponse = Result<number[], ExceptionBase>;
 export abstract class MovieTrendingProvider {
-  abstract getTrending(): Promise<MovieTrendingReponse>;
+  abstract getTrending(): Promise<MovieTrendingResponse>;
+}
+
+export type MovieDiscoverOptions = {
+  page?: number;
+  withCompanyId?: number;
+};
+export type MovieDiscoverResponse = Result<number[], ExceptionBase>;
+export abstract class MovieDiscoverProvider {
+  abstract getDiscover(
+    options?: MovieDiscoverOptions,
+  ): Promise<MovieDiscoverResponse>;
 }

server/src/services/movie/provider/servarr/servarr.ts

@@ -14,7 +14,7 @@ import {
 } from '@/services/movie/provider/provider';
 
 @Service()
-export class ServarrMovieRatingProvider implements MovieRatingProvider {
+export class ServarrMovieProvider implements MovieRatingProvider {
   /**
    * The default time-to-live (TTL) for caching movie ratings data.
    * The value is set to 1 day (86400000 milliseconds).