diff --git a/release-notes/request-status-season-query.md b/release-notes/request-status-season-query.md new file mode 100644 index 000000000..d57cbae8b --- /dev/null +++ b/release-notes/request-status-season-query.md @@ -0,0 +1,9 @@ +--- +category: fixed +audience: users, operators +area: requests +action: none +breaking: false +--- + +Request status pages now load a series’ library seasons and requested seasons independently, keeping large TV request histories responsive while preserving their displayed details. diff --git a/server/lib/mediaRequestHydration.ts b/server/lib/mediaRequestHydration.ts index 270fa1e26..ef61713fd 100644 --- a/server/lib/mediaRequestHydration.ts +++ b/server/lib/mediaRequestHydration.ts @@ -1,7 +1,10 @@ import { getRepository } from '@server/datasource'; +import Media from '@server/entity/Media'; import { MediaRequest } from '@server/entity/MediaRequest'; import { In } from 'typeorm'; +const RELATION_HYDRATION_BATCH_SIZE = 500; + export const hydrateMediaRequestRelations = async ( requests: MediaRequest[], options: { includeMediaIdentifiers?: boolean } = {} @@ -13,18 +16,68 @@ export const hydrateMediaRequestRelations = async ( return requests; } - const hydrated = await getRepository(MediaRequest).find({ - where: { id: In(ids) }, - relations: { - media: options.includeMediaIdentifiers ? { identifiers: true } : true, - seasons: true, - modifiedBy: true, - requestedBy: true, - }, - // This helper receives an explicit id list without pagination, so the join - // strategy safely loads nested media identifiers. TypeORM's query strategy - // does not reliably load media.identifiers for this nested relation. - }); + const requestRepository = getRepository(MediaRequest); + const hydrated: MediaRequest[] = []; + for ( + let offset = 0; + offset < ids.length; + offset += RELATION_HYDRATION_BATCH_SIZE + ) { + const batch = ids.slice(offset, offset + RELATION_HYDRATION_BATCH_SIZE); + hydrated.push( + ...(await requestRepository.find({ + where: { id: In(batch) }, + relations: { + media: true, + seasons: true, + modifiedBy: true, + requestedBy: true, + }, + relationLoadStrategy: 'query', + loadEagerRelations: false, + })) + ); + } + + // Request seasons and media seasons are independent one-to-many relations. + // Load the media collections in their own bounded queries so a request with + // many selected seasons cannot multiply rows across both collections. + const mediaIds = [...new Set(hydrated.map((request) => request.media.id))]; + const mediaRows: Media[] = []; + for ( + let offset = 0; + offset < mediaIds.length; + offset += RELATION_HYDRATION_BATCH_SIZE + ) { + const batch = mediaIds.slice( + offset, + offset + RELATION_HYDRATION_BATCH_SIZE + ); + mediaRows.push( + ...(await getRepository(Media).find({ + where: { id: In(batch) }, + relations: { + seasons: true, + ...(options.includeMediaIdentifiers ? { identifiers: true } : {}), + }, + relationLoadStrategy: 'query', + loadEagerRelations: false, + })) + ); + } + + const mediaById = new Map(mediaRows.map((media) => [media.id, media])); + for (const request of hydrated) { + const media = mediaById.get(request.media.id); + if (!media) { + continue; + } + request.media.seasons = media.seasons; + if (options.includeMediaIdentifiers) { + request.media.identifiers = media.identifiers; + } + } + const hydratedById = new Map( hydrated.map((request) => [request.id, request]) ); diff --git a/server/lib/requestStatus.ts b/server/lib/requestStatus.ts index 37c6f4f0e..ea3cc3043 100644 --- a/server/lib/requestStatus.ts +++ b/server/lib/requestStatus.ts @@ -18,6 +18,7 @@ import type { } from '@server/lib/downloadtracker'; import downloadTracker from '@server/lib/downloadtracker'; import { getExternalRuntimeConfig } from '@server/lib/externalRuntimeConfig'; +import { hydrateMediaRequestRelations } from '@server/lib/mediaRequestHydration'; import { getRequestedMusicSearchTime, reconcileRequestedMusicAvailability, @@ -1267,10 +1268,12 @@ const loadRequest = async ( { where: { id: requestId }, relations: { - media: true, + media: { seasons: true }, seasons: true, requestedBy: true, }, + relationLoadStrategy: 'query', + loadEagerRelations: false, } ); @@ -1842,11 +1845,8 @@ export const getRequestStatusPage = async (options: { const query = requestRepository .createQueryBuilder('request') .leftJoinAndSelect('request.media', 'media') - .leftJoinAndSelect('media.seasons', 'mediaSeasons') - .leftJoinAndSelect('media.identifiers', 'identifiers') .leftJoinAndSelect('request.requestedBy', 'requestedBy') - .leftJoinAndSelect('request.modifiedBy', 'modifiedBy') - .leftJoinAndSelect('request.seasons', 'seasons'); + .leftJoinAndSelect('request.modifiedBy', 'modifiedBy'); if (options.requestId) { query.andWhere('request.id = :requestId', { @@ -1916,6 +1916,10 @@ export const getRequestStatusPage = async (options: { .getManyAndCount(); } + requests = await hydrateMediaRequestRelations(requests, { + includeMediaIdentifiers: true, + }); + const requestIds = requests.map((request) => request.id); const [latestEvents, pendingRequestIds, bookSearchStates] = await Promise.all( [ diff --git a/server/routes/request.test.ts b/server/routes/request.test.ts index 90b9d3a2d..91c098ff3 100644 --- a/server/routes/request.test.ts +++ b/server/routes/request.test.ts @@ -1009,6 +1009,92 @@ describe('GET /request/status', () => { ); }); + it('loads media and requested TV seasons without multiplying their rows', async () => { + const requestedBy = await getRepository(User).findOneByOrFail({ id: 2 }); + const seasonNumbers = Array.from({ length: 40 }, (_, index) => index + 1); + const media = await getRepository(Media).save( + new Media({ + mediaType: MediaType.TV, + tmdbId: 12349, + status: MediaStatus.PARTIALLY_AVAILABLE, + status4k: MediaStatus.UNKNOWN, + seasons: seasonNumbers.map( + (seasonNumber) => + new Season({ + seasonNumber, + status: MediaStatus.UNKNOWN, + status4k: MediaStatus.UNKNOWN, + }) + ), + }) + ); + const mediaRequest = await getRepository(MediaRequest).save( + new MediaRequest({ + type: MediaType.TV, + status: MediaRequestStatus.APPROVED, + media, + requestedBy, + is4k: false, + seasons: seasonNumbers.map( + (seasonNumber) => + new SeasonRequest({ + seasonNumber, + status: MediaRequestStatus.APPROVED, + }) + ), + }) + ); + const agent = await loginAs('friend@seerr.dev', 'test1234'); + const capturedQueries: string[] = []; + const priorLogging = dataSource.options.logging; + const priorLogQuery = dataSource.logger.logQuery; + Reflect.set(dataSource.options, 'logging', ['query']); + dataSource.logger.logQuery = (query) => { + capturedQueries.push(query); + }; + + try { + const listResponse = await agent.get('/request/status'); + + assert.strictEqual(listResponse.status, 200); + assert.strictEqual(listResponse.body.results.length, 1); + assert.strictEqual( + listResponse.body.results[0].request.media.seasons.length, + 40 + ); + assert.strictEqual( + listResponse.body.results[0].request.seasons.length, + 40 + ); + + const response = await agent.get(`/request/status/${mediaRequest.id}`); + + assert.strictEqual(response.status, 200); + assert.strictEqual(response.body.request.media.seasons.length, 40); + assert.strictEqual(response.body.request.seasons.length, 40); + + const hasTable = (query: string, table: string) => + new RegExp(`(?:FROM|JOIN)\\s+"${table}"\\s`, 'i').test(query); + const fanOutQueries = capturedQueries.filter( + (query) => + hasTable(query, 'season') && hasTable(query, 'season_request') + ); + + assert.ok(capturedQueries.some((query) => hasTable(query, 'season'))); + assert.ok( + capturedQueries.some((query) => hasTable(query, 'season_request')) + ); + assert.strictEqual( + fanOutQueries.length, + 0, + 'one SQL statement must not join both season collections' + ); + } finally { + Reflect.set(dataSource.options, 'logging', priorLogging); + dataSource.logger.logQuery = priorLogQuery; + } + }); + it('does not leak another user’s status history to an ordinary viewer', async () => { await seedRequest(); const admin = await getRepository(User).findOneOrFail({ diff --git a/server/routes/request.ts b/server/routes/request.ts index 500e9217f..2d5b24c34 100644 --- a/server/routes/request.ts +++ b/server/routes/request.ts @@ -3432,19 +3432,41 @@ requestRoutes.get< return next({ status: 404, message: 'Request not found.' }); } - const request = await getRepository(MediaRequest).findOne({ + const requestRepository = getRepository(MediaRequest); + const request = await requestRepository.findOne({ where: { id: requestId }, relations: { - media: { identifiers: true, seasons: true }, + media: true, modifiedBy: true, requestedBy: true, - seasons: true, }, + loadEagerRelations: false, }); if (!request) { return next({ status: 404, message: 'Request not found.' }); } + const [identifiers, mediaSeasons, requestedSeasons] = await Promise.all([ + getRepository(Media) + .createQueryBuilder() + .relation(Media, 'identifiers') + .of(request.media.id) + .loadMany(), + getRepository(Media) + .createQueryBuilder() + .relation(Media, 'seasons') + .of(request.media.id) + .loadMany(), + requestRepository + .createQueryBuilder() + .relation(MediaRequest, 'seasons') + .of(request.id) + .loadMany(), + ]); + request.media.identifiers = identifiers; + request.media.seasons = mediaSeasons; + request.seasons = requestedSeasons; + return await runUserSecurityReadWithActor( req.user!.id, request.requestedBy.id,