cross-seed 6.0.0-4 → 6.0.0-40

package/dist/torznab.js

@@ -1,22 +1,15 @@
+import chalk from "chalk";
 import ms from "ms";
+import { inspect } from "util";
 import xml2js from "xml2js";
-import { EP_REGEX, SEASON_REGEX, USER_AGENT } from "./constants.js";
+import { arrIdsEqual, formatFoundIds, getRelevantArrIds, scanAllArrsForMedia, } from "./arr.js";
+import { CALIBRE_INDEXNUM_REGEX, EP_REGEX, SEASON_REGEX, UNKNOWN_TRACKER, USER_AGENT, } from "./constants.js";
 import { db } from "./db.js";
 import { CrossSeedError } from "./errors.js";
-import { getEnabledIndexers, IndexerStatus, updateIndexerStatus, } from "./indexers.js";
-import { Label, logger } from "./logger.js";
+import { ALL_CAPS, getAllIndexers, getEnabledIndexers, IndexerStatus, updateIndexerCapsById, updateIndexerStatus, } from "./indexers.js";
+import { Label, logger, logOnce } from "./logger.js";
 import { getRuntimeConfig } from "./runtimeConfig.js";
-import { hasVideo } from "./searchee.js";
-import { getAnimeQueries, cleanseSeparators, getTag, MediaType, nMsAgo, reformatTitleForSearching, stripExtension, } from "./utils.js";
-function sanitizeUrl(url) {
-    if (typeof url === "string") {
-        url = new URL(url);
-    }
-    return url.origin + url.pathname;
-}
-function getApikey(url) {
-    return new URL(url).searchParams.get("apikey");
-}
+import { cleanTitle, combineAsyncIterables, extractInt, formatAsList, getAnimeQueries, getApikey, getLogString, getMediaType, isTruthy, MediaType, nMsAgo, reformatTitleForSearching, sanitizeUrl, stripExtension, stripMetaFromName, } from "./utils.js";
 function parseTorznabResults(xml) {
     const items = xml?.rss?.channel?.[0]?.item;
     if (!items || !Array.isArray(items)) {
@@ -28,124 +21,274 @@ function parseTorznabResults(xml) {
         tracker: item?.prowlarrindexer?.[0]?._ ??
             item?.jackettindexer?.[0]?._ ??
             item?.indexer?.[0]?._ ??
-            "Unknown tracker",
+            UNKNOWN_TRACKER,
         link: item.link[0],
         size: Number(item.size[0]),
         pubDate: new Date(item.pubDate[0]).getTime(),
     }));
 }
 function parseTorznabCaps(xml) {
-    const capsSection = xml?.caps?.searching?.[0];
+    const limits = xml?.caps?.limits?.map((limit) => ({
+        default: parseInt(limit.$.default),
+        max: parseInt(limit.$.max),
+    }))[0] ?? { default: 100, max: 100 };
+    const searchingSection = xml?.caps?.searching?.[0];
     const isAvailable = (searchTechnique) => searchTechnique?.[0]?.$?.available === "yes";
+    function getSupportedIds(searchTechnique) {
+        const supportedParamsStr = searchTechnique?.[0]?.$?.supportedParams;
+        const supportedIds = supportedParamsStr
+            ?.split(",")
+            ?.filter((token) => token.includes("id")) ?? [];
+        return {
+            tvdbId: supportedIds.includes("tvdbid"),
+            tmdbId: supportedIds.includes("tmdbid"),
+            imdbId: supportedIds.includes("imdbid"),
+            tvMazeId: supportedIds.includes("tvmazeid"),
+        };
+    }
+    const categoryCaps = xml?.caps?.categories?.[0]?.category;
+    function getCatCaps(item) {
+        const categories = (item ?? []).map((cat) => ({
+            id: parseInt(cat.$.id),
+            name: cat.$.name.toLowerCase(),
+        }));
+        const caps = {
+            movie: false,
+            tv: false,
+            anime: false,
+            xxx: false,
+            audio: false,
+            book: false,
+            additional: false,
+        };
+        const keys = Object.keys(caps);
+        keys.splice(keys.indexOf("additional"), 1);
+        for (const { id, name } of categories) {
+            let isAdditional = true;
+            for (const cap of keys) {
+                if (name.includes(cap)) {
+                    caps[cap] = true;
+                    isAdditional = false;
+                }
+            }
+            if (isAdditional && id < 100000 && (id < 8000 || id > 8999)) {
+                caps.additional = true;
+            }
+        }
+        return caps;
+    }
     return {
-        search: Boolean(isAvailable(capsSection?.search)),
-        tvSearch: Boolean(isAvailable(capsSection?.["tv-search"])),
-        movieSearch: Boolean(isAvailable(capsSection?.["movie-search"])),
+        search: Boolean(isAvailable(searchingSection?.search)),
+        tvSearch: Boolean(isAvailable(searchingSection?.["tv-search"])),
+        movieSearch: Boolean(isAvailable(searchingSection?.["movie-search"])),
+        movieIdSearch: getSupportedIds(searchingSection?.["movie-search"]),
+        tvIdSearch: getSupportedIds(searchingSection?.["tv-search"]),
+        categories: getCatCaps(categoryCaps),
+        limits,
     };
 }
-function createTorznabSearchQueries(searchee, caps) {
-    const nameWithoutExtension = stripExtension(searchee.name);
-    const isVideo = hasVideo(searchee);
-    const extractNumber = (str) => parseInt(str.match(/\d+/)[0]);
-    const mediaType = getTag(nameWithoutExtension, isVideo);
+async function createTorznabSearchQueries(searchee, mediaType, caps, parsedMedia) {
+    const stem = stripExtension(searchee.title);
+    const relevantIds = parsedMedia
+        ? await getRelevantArrIds(caps, parsedMedia)
+        : {};
+    const useIds = Object.values(relevantIds).some(isTruthy);
     if (mediaType === MediaType.EPISODE && caps.tvSearch) {
-        const match = nameWithoutExtension.match(EP_REGEX);
+        const match = stem.match(EP_REGEX);
+        const groups = match.groups;
         return [
             {
                 t: "tvsearch",
-                q: cleanseSeparators(match.groups.title),
-                season: match.groups.season
-                    ? extractNumber(match.groups.season)
-                    : match.groups.year,
-                ep: match.groups.episode
-                    ? extractNumber(match.groups.episode)
-                    : `${match.groups.month}/${match.groups.day}`,
+                q: useIds ? undefined : reformatTitleForSearching(stem),
+                season: groups.season ? extractInt(groups.season) : groups.year,
+                ep: groups.episode
+                    ? extractInt(groups.episode)
+                    : `${groups.month}/${groups.day}`,
+                ...relevantIds,
             },
         ];
     }
     else if (mediaType === MediaType.SEASON && caps.tvSearch) {
-        const match = nameWithoutExtension.match(SEASON_REGEX);
+        const match = stem.match(SEASON_REGEX);
+        const groups = match.groups;
         return [
             {
                 t: "tvsearch",
-                q: cleanseSeparators(match.groups.title),
-                season: extractNumber(match.groups.season),
+                q: useIds ? undefined : reformatTitleForSearching(stem),
+                season: extractInt(groups.season),
+                ...relevantIds,
+            },
+        ];
+    }
+    else if (mediaType === MediaType.MOVIE && caps.movieSearch) {
+        return [
+            {
+                t: "movie",
+                q: useIds ? undefined : reformatTitleForSearching(stem),
+                ...relevantIds,
             },
         ];
     }
+    if (useIds && caps.tvSearch && parsedMedia?.series) {
+        const eps = parsedMedia.episodes;
+        const season = eps.length > 0 ? eps[0].seasonNumber : undefined;
+        const ep = eps.length === 1 ? eps[0].episodeNumber : undefined;
+        return [
+            { t: "tvsearch", q: undefined, season, ep, ...relevantIds },
+        ];
+    }
+    else if (useIds && caps.movieSearch && parsedMedia?.movie) {
+        return [{ t: "movie", q: undefined, ...relevantIds }];
+    }
     else if (mediaType === MediaType.ANIME) {
-        const animeQueries = getAnimeQueries(nameWithoutExtension);
-        return animeQueries.map((animeQuery) => ({
+        return getAnimeQueries(stem).map((animeQuery) => ({
             t: "search",
             q: animeQuery,
         }));
     }
-    else {
+    else if (mediaType === MediaType.VIDEO) {
         return [
             {
                 t: "search",
-                q: reformatTitleForSearching(nameWithoutExtension),
+                q: cleanTitle(stripMetaFromName(stem)),
             },
         ];
     }
+    else if (mediaType === MediaType.BOOK && searchee.path) {
+        return [
+            {
+                t: "search",
+                q: cleanTitle(stem.replace(CALIBRE_INDEXNUM_REGEX, "")),
+            },
+        ];
+    }
+    return [
+        {
+            t: "search",
+            q: cleanTitle(stem),
+        },
+    ];
 }
-export async function queryRssFeeds() {
-    const candidatesByUrl = await makeRequests(await getEnabledIndexers(), () => [{ t: "search", q: "" }]);
-    return candidatesByUrl.flatMap((e) => e.candidates);
+export async function getSearchString(searchee) {
+    const mediaType = getMediaType(searchee);
+    const params = (await createTorznabSearchQueries(searchee, mediaType, ALL_CAPS))[0];
+    const season = params.season !== undefined ? `.S${params.season}` : "";
+    const ep = params.ep !== undefined ? `.E${params.ep}` : "";
+    return `${params.q}${season}${ep}`.toLowerCase();
 }
-export async function searchTorznab(searchee) {
-    const { excludeRecentSearch, excludeOlder, torznab } = getRuntimeConfig();
+/**
+ * Only for testing purposes. (createTorznabSearchQueries now accepts searchee
+ * instead of stem (title))
+ *
+ * Logs the queries that would be sent to indexers for id and non-id searches.
+ * Ensure that item exists in your arr for the id search example.
+ * Ensure mediaType is what cross-seed would actually parse the item as.
+ */
+export async function logQueries(searcheeTitle, mediaType) {
+    const stem = stripExtension(searcheeTitle);
+    logger.info(
+    // @ts-expect-error needs conversion to use searchee instead of stem
+    `RAW: ${inspect(await createTorznabSearchQueries(stem, mediaType, ALL_CAPS))}`);
+    const res = await scanAllArrsForMedia(searcheeTitle, mediaType);
+    const parsedMedia = res.isOk() ? res.unwrap() : undefined;
+    logger.info(
+    // @ts-expect-error needs conversion to use searchee instead of stem
+    `ID: ${inspect(await createTorznabSearchQueries(stem, mediaType, ALL_CAPS, parsedMedia))}`);
+}
+export function indexerDoesSupportMediaType(mediaType, caps) {
+    switch (mediaType) {
+        case MediaType.EPISODE:
+        case MediaType.SEASON:
+            return caps.tv;
+        case MediaType.MOVIE:
+            return caps.movie;
+        case MediaType.ANIME:
+        case MediaType.VIDEO:
+            return caps.movie || caps.tv || caps.anime || caps.xxx;
+        case MediaType.AUDIO:
+            return caps.audio;
+        case MediaType.BOOK:
+            return caps.book;
+        case MediaType.OTHER:
+            return caps.additional;
+    }
+}
+export async function* rssPager(indexer, pageBackUntil) {
+    let earliestSeen = Infinity;
+    const limit = indexer.limits.max;
+    for (let i = 0; i < 10; i++) {
+        let currentPageCandidates;
+        try {
+            currentPageCandidates = await makeRequest({
+                indexerId: indexer.id,
+                baseUrl: indexer.url,
+                apikey: indexer.apikey,
+                query: { t: "search", q: "", limit, offset: i * limit },
+            });
+        }
+        catch (e) {
+            logger.error({
+                label: Label.TORZNAB,
+                message: `Paging indexer ${indexer.id} stopped: request failed for page ${i + 1}`,
+            });
+            logger.debug(e);
+            return;
+        }
+        const allNewPubDates = currentPageCandidates.map((c) => c.pubDate);
+        const currentPageEarliest = Math.min(...allNewPubDates);
+        const currentPageLatest = Math.max(...allNewPubDates);
+        const newCandidates = currentPageCandidates.filter((c) => c.pubDate < earliestSeen && c.pubDate >= pageBackUntil);
+        if (currentPageLatest > Date.now() + ms("10 minutes")) {
+            logOnce(`timezone-issues-${indexer.id}`, () => void logger.warn(`Indexer ${indexer.url} reported releases in the future. Its timezone may be misconfigured.`), ms("10 minutes"));
+        }
+        if (!newCandidates.length) {
+            logger.verbose({
+                label: Label.TORZNAB,
+                message: `Paging indexer ${indexer.id} stopped: nothing new in page ${i + 1}`,
+            });
+            return;
+        }
+        logger.verbose({
+            label: Label.TORZNAB,
+            message: `${newCandidates.length} new candidates on indexer ${indexer.id} page ${i + 1}`,
+        });
+        // yield each new candidate
+        yield* newCandidates;
+        earliestSeen = Math.min(earliestSeen, currentPageEarliest);
+    }
+    logger.verbose({
+        label: Label.TORZNAB,
+        message: `Paging indexer ${indexer.url} stopped: reached 10 pages`,
+    });
+}
+export async function* queryRssFeeds(pageBackUntil) {
+    const indexers = await getEnabledIndexers();
+    yield* combineAsyncIterables(indexers.map((indexer) => rssPager(indexer, pageBackUntil)));
+}
+export async function searchTorznab(searchee, cachedSearch, progress) {
+    const { torznab } = getRuntimeConfig();
     if (torznab.length === 0) {
         throw new Error("no indexers are available");
     }
-    const enabledIndexers = await getEnabledIndexers();
-    const name = searchee.name;
-    // search history for name across all indexers
-    const timestampDataSql = await db("searchee")
-        .join("timestamp", "searchee.id", "timestamp.searchee_id")
-        .join("indexer", "timestamp.indexer_id", "indexer.id")
-        .whereIn("indexer.id", enabledIndexers.map((i) => i.id))
-        .andWhere({ name })
-        .select({
-        indexerId: "indexer.id",
-        firstSearched: "timestamp.first_searched",
-        lastSearched: "timestamp.last_searched",
+    const mediaType = getMediaType(searchee);
+    const { indexersToSearch, parsedMedia } = await getAndLogIndexers(searchee, cachedSearch, mediaType, progress);
+    const indexerCandidates = await makeRequests(indexersToSearch, async (indexer) => {
+        const caps = {
+            search: indexer.searchCap,
+            tvSearch: indexer.tvSearchCap,
+            movieSearch: indexer.movieSearchCap,
+            tvIdSearch: indexer.tvIdCaps,
+            movieIdSearch: indexer.movieIdCaps,
+            categories: indexer.categories,
+            limits: indexer.limits,
+        };
+        return await createTorznabSearchQueries(searchee, mediaType, caps, parsedMedia);
     });
-    const indexersToUse = enabledIndexers.filter((indexer) => {
-        const entry = timestampDataSql.find((entry) => entry.indexerId === indexer.id);
-        return (!entry ||
-            ((!excludeOlder || entry.firstSearched > nMsAgo(excludeOlder)) &&
-                (!excludeRecentSearch ||
-                    entry.lastSearched < nMsAgo(excludeRecentSearch))));
-    });
-    const timestampCallout = " (filtered by timestamps)";
-    logger.info({
-        label: Label.TORZNAB,
-        message: `Searching ${indexersToUse.length} indexers for ${name}${indexersToUse.length < enabledIndexers.length
-            ? timestampCallout
-            : ""}`,
-    });
-    return makeRequests(indexersToUse, (indexer) => createTorznabSearchQueries(searchee, {
-        search: indexer.searchCap,
-        tvSearch: indexer.tvSearchCap,
-        movieSearch: indexer.movieSearchCap,
-    }));
+    return [...cachedSearch.indexerCandidates, ...indexerCandidates];
 }
 export async function syncWithDb() {
     const { torznab } = getRuntimeConfig();
-    const dbIndexers = await db("indexer")
-        .where({ active: true })
-        .select({
-        id: "id",
-        url: "url",
-        apikey: "apikey",
-        active: "active",
-        status: "status",
-        retryAfter: "retry_after",
-        searchCap: "search_cap",
-        tvSearchCap: "tv_search_cap",
-        movieSearchCap: "movie_search_cap",
-    });
+    const dbIndexers = await getAllIndexers();
     const inConfigButNotInDb = torznab.filter((configIndexer) => !dbIndexers.some((dbIndexer) => dbIndexer.url === sanitizeUrl(configIndexer)));
     const inDbButNotInConfig = dbIndexers.filter((dbIndexer) => !torznab.some((configIndexer) => sanitizeUrl(configIndexer) === dbIndexer.url));
     const apikeyUpdates = dbIndexers.reduce((acc, dbIndexer) => {
@@ -186,8 +329,8 @@ export async function syncWithDb() {
             .update({ status: IndexerStatus.OK });
     });
 }
-function assembleUrl(urlStr, apikey, params) {
-    const url = new URL(urlStr);
+export function assembleUrl(baseUrl, apikey, params) {
+    const url = new URL(baseUrl);
     const searchParams = new URLSearchParams();
     searchParams.set("apikey", apikey);
     for (const [key, value] of Object.entries(params)) {
@@ -200,18 +343,18 @@ function assembleUrl(urlStr, apikey, params) {
 async function fetchCaps(indexer) {
     let response;
     try {
-        response = await fetch(assembleUrl(indexer.url, indexer.apikey, { t: "caps" }));
+        response = await fetch(assembleUrl(indexer.url, indexer.apikey, { t: "caps" }), { signal: AbortSignal.timeout(ms("10 seconds")) });
     }
     catch (e) {
         const error = new Error(`Indexer ${indexer.url} failed to respond, check verbose logs`);
-        logger.error(error);
+        logger.error(error.message);
         logger.debug(e);
         throw error;
     }
     const responseText = await response.text();
     if (!response.ok) {
         const error = new Error(`Indexer ${indexer.url} responded with code ${response.status} when fetching caps, check verbose logs`);
-        logger.error(error);
+        logger.error(error.message);
         logger.debug(`Response body first 1000 characters: ${responseText.substring(0, 1000)}`);
         throw error;
     }
@@ -221,7 +364,7 @@ async function fetchCaps(indexer) {
     }
     catch (_) {
         const error = new Error(`Indexer ${indexer.url} responded with invalid XML when fetching caps, check verbose logs`);
-        logger.error(error);
+        logger.error(error.message);
         logger.debug(`Response body first 1000 characters: ${responseText.substring(0, 1000)}`);
         throw error;
     }
@@ -237,15 +380,12 @@ function collateOutcomes(correlators, outcomes) {
         return { rejected, fulfilled };
     }, { rejected: [], fulfilled: [] });
 }
-async function updateCaps(indexers) {
+export async function updateCaps() {
+    const indexers = await getAllIndexers();
     const outcomes = await Promise.allSettled(indexers.map((indexer) => fetchCaps(indexer)));
     const { fulfilled } = collateOutcomes(indexers.map((i) => i.id), outcomes);
     for (const [indexerId, caps] of fulfilled) {
-        await db("indexer").where({ id: indexerId }).update({
-            search_cap: caps.search,
-            tv_search_cap: caps.tvSearch,
-            movie_search_cap: caps.movieSearch,
-        });
+        await updateIndexerCapsById(indexerId, caps);
     }
 }
 export async function validateTorznabUrls() {
@@ -262,16 +402,7 @@ export async function validateTorznabUrls() {
         }
     }
     await syncWithDb();
-    const enabledIndexersWithoutCaps = await db("indexer")
-        .where({
-        active: true,
-        search_cap: null,
-        tv_search_cap: null,
-        movie_search_cap: null,
-    })
-        .orWhere({ search_cap: false, active: true })
-        .select({ id: "id", url: "url", apikey: "apikey" });
-    await updateCaps(enabledIndexersWithoutCaps);
+    await updateCaps();
     const indexersWithoutSearch = await db("indexer")
         .where({ search_cap: false, active: true })
         .select({ id: "id", url: "url" });
@@ -283,44 +414,56 @@ export async function validateTorznabUrls() {
         logger.warn("no working indexers available");
     }
 }
-async function makeRequests(indexers, getQueries) {
+/**
+ * Snooze indexers based on the response headers and status code.
+ * specifically for a search, probably not applicable to a caps fetch.
+ */
+async function onResponseNotOk(response, indexerId) {
+    const retryAfterSeconds = Number(response.headers.get("Retry-After"));
+    const retryAfter = !Number.isNaN(retryAfterSeconds)
+        ? Date.now() + ms(`${retryAfterSeconds} seconds`)
+        : response.status === 429
+            ? Date.now() + ms("1 hour")
+            : Date.now() + ms("10 minutes");
+    await updateIndexerStatus(response.status === 429
+        ? IndexerStatus.RATE_LIMITED
+        : IndexerStatus.UNKNOWN_ERROR, retryAfter, [indexerId]);
+}
+async function makeRequest(request) {
     const { searchTimeout } = getRuntimeConfig();
-    const searchUrls = indexers.flatMap((indexer) => getQueries(indexer).map((query) => assembleUrl(indexer.url, indexer.apikey, query)));
-    searchUrls.forEach((message) => void logger.verbose({ label: Label.TORZNAB, message }));
-    const abortControllers = searchUrls.map(() => new AbortController());
-    if (typeof searchTimeout === "number") {
-        setTimeout(() => {
-            for (const abortController of abortControllers) {
-                abortController.abort();
-            }
-        }, searchTimeout).unref();
-    }
-    const outcomes = await Promise.allSettled(searchUrls.map((url, i) => fetch(url, {
+    const url = assembleUrl(request.baseUrl, request.apikey, request.query);
+    const abortSignal = typeof searchTimeout === "number"
+        ? AbortSignal.timeout(searchTimeout)
+        : undefined;
+    logger.verbose({
+        label: Label.TORZNAB,
+        message: `Querying indexer ${request.indexerId} at ${request.baseUrl} with ${inspect(request.query)}`,
+    });
+    const response = await fetch(url, {
         headers: { "User-Agent": USER_AGENT },
-        signal: abortControllers[i].signal,
-    })
-        .then((response) => {
-        if (!response.ok) {
-            const retryAfterSeconds = Number(response.headers.get("Retry-After"));
-            if (!Number.isNaN(retryAfterSeconds)) {
-                updateIndexerStatus(response.status === 429
-                    ? IndexerStatus.RATE_LIMITED
-                    : IndexerStatus.UNKNOWN_ERROR, Date.now() + ms(`${retryAfterSeconds} seconds`), [indexers[i].id]);
-            }
-            else {
-                updateIndexerStatus(response.status === 429
-                    ? IndexerStatus.RATE_LIMITED
-                    : IndexerStatus.UNKNOWN_ERROR, response.status === 429
-                    ? Date.now() + ms("1 hour")
-                    : Date.now() + ms("10 minutes"), [indexers[i].id]);
-            }
-            throw new Error(`request failed with code: ${response.status}`);
-        }
-        return response.text();
-    })
-        .then(xml2js.parseStringPromise)
-        .then(parseTorznabResults)));
-    const { rejected, fulfilled } = collateOutcomes(indexers.map((indexer) => indexer.id), outcomes);
+        signal: abortSignal,
+    });
+    if (!response.ok) {
+        await onResponseNotOk(response, request.indexerId);
+        throw new Error(`request failed with code: ${response.status}`);
+    }
+    const xml = await response.text();
+    const torznabResults = await xml2js.parseStringPromise(xml);
+    return parseTorznabResults(torznabResults);
+}
+async function makeRequests(indexers, getQueriesForIndexer) {
+    const requests = [];
+    for (const indexer of indexers) {
+        const queries = await getQueriesForIndexer(indexer);
+        requests.push(...queries.map((query) => ({
+            indexerId: indexer.id,
+            baseUrl: indexer.url,
+            apikey: indexer.apikey,
+            query,
+        })));
+    }
+    const outcomes = await Promise.allSettled(requests.map(makeRequest));
+    const { rejected, fulfilled } = collateOutcomes(requests.map((request) => request.indexerId), outcomes);
     for (const [indexerId, reason] of rejected) {
         logger.warn(`Failed to reach ${indexers.find((i) => i.id === indexerId).url}`);
         logger.debug(reason);
@@ -330,4 +473,89 @@ async function makeRequests(indexers, getQueries) {
         candidates: results,
     }));
 }
+async function getAndLogIndexers(searchee, cachedSearch, mediaType, progress) {
+    const { excludeRecentSearch, excludeOlder } = getRuntimeConfig();
+    const searcheeLog = getLogString(searchee, chalk.bold.white);
+    const mediaTypeLog = chalk.white(mediaType.toUpperCase());
+    const enabledIndexers = await getEnabledIndexers();
+    // search history for name across all indexers
+    const name = searchee.title;
+    const timestampDataSql = await db("searchee")
+        .join("timestamp", "searchee.id", "timestamp.searchee_id")
+        .join("indexer", "timestamp.indexer_id", "indexer.id")
+        .whereIn("indexer.id", enabledIndexers.map((i) => i.id))
+        .andWhere({ name })
+        .select({
+        indexerId: "indexer.id",
+        firstSearched: "timestamp.first_searched",
+        lastSearched: "timestamp.last_searched",
+    });
+    const skipBefore = searchee.label !== Label.WEBHOOK && excludeOlder
+        ? nMsAgo(excludeOlder)
+        : Number.NEGATIVE_INFINITY;
+    const skipAfter = searchee.label !== Label.WEBHOOK && excludeRecentSearch
+        ? nMsAgo(excludeRecentSearch)
+        : Number.POSITIVE_INFINITY;
+    const timeFilteredIndexers = enabledIndexers.filter((indexer) => {
+        const entry = timestampDataSql.find((entry) => entry.indexerId === indexer.id);
+        if (!entry)
+            return true;
+        if (entry.firstSearched < skipBefore)
+            return false;
+        if (entry.lastSearched > skipAfter)
+            return false;
+        return true;
+    });
+    const indexersToUse = timeFilteredIndexers.filter((indexer) => {
+        return indexerDoesSupportMediaType(mediaType, indexer.categories);
+    });
+    // Invalidate cache if searchStr or ids is different
+    let shouldScanArr = true;
+    let parsedMedia;
+    const searchStr = await getSearchString(searchee);
+    if (cachedSearch.q === searchStr) {
+        shouldScanArr = false;
+        const res = await scanAllArrsForMedia(name, mediaType);
+        parsedMedia = res.isOk() ? res.unwrap() : undefined;
+        const ids = parsedMedia?.movie ?? parsedMedia?.series;
+        if (!arrIdsEqual(ids, cachedSearch.ids)) {
+            cachedSearch.indexerCandidates.length = 0;
+            cachedSearch.ids = ids;
+        }
+    }
+    else {
+        cachedSearch.q = searchStr;
+        cachedSearch.indexerCandidates.length = 0;
+        cachedSearch.ids = undefined; // Don't prematurely get ids if skipping
+    }
+    const indexersToSearch = indexersToUse.filter((indexer) => {
+        return !cachedSearch.indexerCandidates.some((candidates) => candidates.indexerId === indexer.id);
+    });
+    const filteringCauses = [
+        enabledIndexers.length > timeFilteredIndexers.length && "timestamps",
+        timeFilteredIndexers.length > indexersToUse.length && "category",
+    ].filter(isTruthy);
+    const reasonStr = filteringCauses.length
+        ? ` (filtered by ${formatAsList(filteringCauses, { sort: true })})`
+        : "";
+    if (!indexersToSearch.length && !cachedSearch.indexerCandidates.length) {
+        cachedSearch.q = null; // Won't scan arrs for multiple skips in a row
+        logger.info({
+            label: searchee.label,
+            message: `${progress}Skipped searching on indexers for ${searcheeLog}${reasonStr} | MediaType: ${mediaTypeLog} | IDs: N/A`,
+        });
+        return { indexersToSearch };
+    }
+    if (shouldScanArr) {
+        const res = await scanAllArrsForMedia(name, mediaType);
+        parsedMedia = res.isOk() ? res.unwrap() : undefined;
+        cachedSearch.ids = parsedMedia?.movie ?? parsedMedia?.series;
+    }
+    const idsStr = cachedSearch.ids ? formatFoundIds(cachedSearch.ids) : "NONE";
+    logger.info({
+        label: searchee.label,
+        message: `${progress}Searching for ${searcheeLog} | MediaType: ${mediaTypeLog} | IDs: ${idsStr}`,
+    });
+    return { indexersToSearch, parsedMedia };
+}
 //# sourceMappingURL=torznab.js.map