Restore series meta via seasons path; keep TMDB enrich off the critical path.

Series listing broke after switching to series.episodes and selecting stillUrl — revert to the pre-TMDB catalog-aligned query.

Co-authored-by: Cursor <cursoragent@cursor.com>

apps/master-api/src/app.ts

@@ -87,6 +87,19 @@ async function main() {
     console.warn("Could not ensure episodes.still_url:", err);
   }
 
+  // Repair drifted episode.series_id so series.episodes and seasons.episodes stay aligned.
+  try {
+    await prisma.$executeRawUnsafe(`
+      UPDATE episodes e
+      SET series_id = s.series_id
+      FROM seasons s
+      WHERE e.season_id = s.id
+        AND e.series_id IS DISTINCT FROM s.series_id
+    `);
+  } catch (err) {
+    console.warn("Could not repair episode series_id drift:", err);
+  }
+
   const shutdown = async () => {
     console.log("Shutting down...");
     nodeConnectionManager.shutdown();

apps/master-api/src/metadata/service.ts

@@ -48,7 +48,6 @@ function needsEpisodeEnrichment(ep: {
   stillUrl?: string | null;
   overview: string | null;
 }): boolean {
-  if (!ep.stillUrl) return true;
   if (!ep.overview) return true;
   if (!ep.title || /^episode\s+\d+$/i.test(ep.title.trim())) return true;
   return false;
@@ -383,7 +382,6 @@ export class MetadataService {
               episodeNumber: true,
               title: true,
               overview: true,
-              stillUrl: true,
             },
           },
         },
@@ -417,7 +415,21 @@ export class MetadataService {
               },
             });
           } catch {
-            // Column/migration mismatch or concurrent update — skip this episode.
+            // stillUrl column missing — update title/overview only
+            try {
+              await prisma.episode.update({
+                where: { id: ep.id },
+                data: {
+                  title: meta.title,
+                  overview: meta.overview ?? undefined,
+                  runtime: meta.runtime ?? undefined,
+                  tmdbId: meta.tmdbId ?? undefined,
+                  airDate: parseAirDate(meta.airDate),
+                },
+              });
+            } catch {
+              // skip
+            }
           }
         }
         this.enrichedSeriesSeasons.add(key);

apps/master-api/src/stremio/routes.ts

@@ -318,27 +318,96 @@ async function getMovieMeta(id: string) {
 }
 
 async function getSeriesMeta(id: string, metadata: MetadataService) {
-  const series = await loadSeriesForMeta(id);
+  // IMPORTANT: use seasons → episodes (same path as catalog availability filter).
+  // Do not query series.episodes directly — seriesId can drift from season.seriesId.
+  // Do not select stillUrl — that optional column must never break listing.
+  const series = await prisma.series.findFirst({
+    where: {
+      OR: [{ imdbId: id }, { id: unwrapLocalId(id, "series") }],
+    },
+    select: {
+      id: true,
+      title: true,
+      year: true,
+      overview: true,
+      posterUrl: true,
+      backdropUrl: true,
+      genres: true,
+      imdbId: true,
+      seasons: {
+        orderBy: { seasonNumber: "asc" },
+        select: {
+          episodes: {
+            orderBy: [{ seasonNumber: "asc" }, { episodeNumber: "asc" }],
+            select: {
+              seasonNumber: true,
+              episodeNumber: true,
+              title: true,
+              overview: true,
+              airDate: true,
+              mediaFiles: {
+                where: { available: true },
+                take: 1,
+                select: { id: true },
+              },
+            },
+          },
+        },
+      },
+    },
+  });
+
   if (!series) return null;
 
-  // Enrich in background — never block or break episode listing.
+  // TMDB titles/stills only in background — never block or fail meta.
   void metadata.enrichSeriesEpisodes(series.id).catch(() => undefined);
 
   const sid = seriesId(series.imdbId, series.id);
-  const videos = series.episodes
+
-    .filter((ep) => ep.mediaFiles.length > 0)
+  let episodeRows = series.seasons.flatMap((season) =>
-    .map((ep) => ({
+    season.episodes.filter((ep) => ep.mediaFiles.length > 0)
-      id: `${sid}:${ep.seasonNumber}:${ep.episodeNumber}`,
+  );
-      title:
+
-        ep.title && !/^episode\s+\d+$/i.test(ep.title)
+  // Fallback: same season path, but ignore available flag (node blip / prune race).
-          ? ep.title
+  if (episodeRows.length === 0) {
-          : `Episode ${ep.episodeNumber}`,
+    const fallback = await prisma.series.findFirst({
-      season: ep.seasonNumber,
+      where: { id: series.id },
-      episode: ep.episodeNumber,
+      select: {
-      overview: ep.overview ?? undefined,
+        seasons: {
-      thumbnail: ep.stillUrl || undefined,
+          orderBy: { seasonNumber: "asc" },
-      released: formatMetaDate(ep.airDate),
+          select: {
-    }));
+            episodes: {
+              orderBy: [{ seasonNumber: "asc" }, { episodeNumber: "asc" }],
+              select: {
+                seasonNumber: true,
+                episodeNumber: true,
+                title: true,
+                overview: true,
+                airDate: true,
+                mediaFiles: { take: 1, select: { id: true } },
+              },
+            },
+          },
+        },
+      },
+    });
+    episodeRows =
+      fallback?.seasons.flatMap((season) =>
+        season.episodes.filter((ep) => ep.mediaFiles.length > 0)
+      ) ?? [];
+  }
+
+  const videos = episodeRows.map((ep) => ({
+    id: `${sid}:${ep.seasonNumber}:${ep.episodeNumber}`,
+    title:
+      ep.title && !/^episode\s+\d+$/i.test(ep.title)
+        ? ep.title
+        : `Episode ${ep.episodeNumber}`,
+    season: ep.seasonNumber,
+    episode: ep.episodeNumber,
+    overview: ep.overview ?? undefined,
+    released: formatMetaDate(ep.airDate),
+  }));
 
   return {
     id: sid,
@@ -353,115 +422,6 @@ async function getSeriesMeta(id: string, metadata: MetadataService) {
   };
 }
 
-/** Load series + episodes without depending on optional still_url column. */
-async function loadSeriesForMeta(id: string): Promise<{
-  id: string;
-  title: string;
-  year: number | null;
-  overview: string | null;
-  posterUrl: string | null;
-  backdropUrl: string | null;
-  genres: string[];
-  imdbId: string | null;
-  episodes: Array<{
-    seasonNumber: number;
-    episodeNumber: number;
-    title: string | null;
-    overview: string | null;
-    airDate: Date | null;
-    stillUrl: string | null;
-    mediaFiles: Array<{ id: string }>;
-  }>;
-} | null> {
-  const where = {
-    OR: [{ imdbId: id }, { id: unwrapLocalId(id, "series") }],
-  };
-
-  const available = await querySeriesEpisodes(where, true);
-  if (available && available.episodes.some((ep) => ep.mediaFiles.length > 0)) {
-    return available;
-  }
-
-  // Fallback: list episodes that still have files even if marked unavailable
-  // (e.g. brief node disconnect), so Stremio is not empty.
-  const anyFiles = await querySeriesEpisodes(where, false);
-  return anyFiles ?? available;
-}
-
-async function querySeriesEpisodes(
-  where: { OR: Array<{ imdbId: string } | { id: string }> },
-  onlyAvailable: boolean
-) {
-  const mediaFilesArgs = onlyAvailable
-    ? { where: { available: true as const }, take: 1 as const, select: { id: true as const } }
-    : { take: 1 as const, select: { id: true as const } };
-
-  try {
-    const row = await prisma.series.findFirst({
-      where,
-      select: {
-        id: true,
-        title: true,
-        year: true,
-        overview: true,
-        posterUrl: true,
-        backdropUrl: true,
-        genres: true,
-        imdbId: true,
-        episodes: {
-          orderBy: [{ seasonNumber: "asc" as const }, { episodeNumber: "asc" as const }],
-          select: {
-            seasonNumber: true,
-            episodeNumber: true,
-            title: true,
-            overview: true,
-            airDate: true,
-            stillUrl: true,
-            mediaFiles: mediaFilesArgs,
-          },
-        },
-      },
-    });
-    if (row) return row;
-  } catch {
-    // still_url missing — retry without that field
-  }
-
-  try {
-    const row = await prisma.series.findFirst({
-      where,
-      select: {
-        id: true,
-        title: true,
-        year: true,
-        overview: true,
-        posterUrl: true,
-        backdropUrl: true,
-        genres: true,
-        imdbId: true,
-        episodes: {
-          orderBy: [{ seasonNumber: "asc" as const }, { episodeNumber: "asc" as const }],
-          select: {
-            seasonNumber: true,
-            episodeNumber: true,
-            title: true,
-            overview: true,
-            airDate: true,
-            mediaFiles: mediaFilesArgs,
-          },
-        },
-      },
-    });
-    if (!row) return null;
-    return {
-      ...row,
-      episodes: row.episodes.map((ep) => ({ ...ep, stillUrl: null as string | null })),
-    };
-  } catch {
-    return null;
-  }
-}
-
 function formatMetaDate(value: Date | null | undefined): string | undefined {
   if (!value) return undefined;
   const t = value.getTime();