eztv.rss.js

const fs = require('fs');
const argparse = require('argparse');
const RSSParser = require('rss-parser');
const _ = require('lodash');
const parser = require('episode-parser');
const SimpleNodeLogger = require('simple-node-logger');

const log = SimpleNodeLogger.createSimpleLogger({
    timestampFormat: 'YYYY-MM-DD HH:mm:ss.SSS'
});
log.setLevel('info');

const RSS_URL = 'https://myrss.org/eztv';
const DB_PATH = 'eztv.rss.json';

function isNewerEpisode(candidate, current) {
	if (!current) {
		return true;
	}

	// The RSS cache keeps one record per show, so a later season/episode replaces the older one.
	const candidateSeason = Number(candidate.season || 0);
	const currentSeason = Number(current.season || 0);
	if (candidateSeason !== currentSeason) {
		return candidateSeason > currentSeason;
	}

    const candidateEpisode = Number(candidate.episode || 0);
    const currentEpisode = Number(current.episode || 0);
    if (candidateEpisode !== currentEpisode) {
        return candidateEpisode > currentEpisode;
    }

    return false;
}

async function run() {
    const parserArg = new argparse.ArgumentParser({
        description: 'Fetch EZTV RSS feed and maintain a local JSON database.'
    });
    parserArg.addArgument('--max-days', {
        help: 'Number of days to keep entries',
        type: 'int',
        default: 7
    });
    const [args] = parserArg.parseKnownArgs(process.argv);
    const maxDays = args.max_days;

    const rssParser = new RSSParser();
    let db = {};

    try {
        if (fs.existsSync(DB_PATH)) {
            db = JSON.parse(fs.readFileSync(DB_PATH, 'utf8'));
        }
    } catch (err) {
        log.error(`Failed to read database file: ${err.message}`);
        process.exit(1);
    }

    let feed;
    try {
        log.info(`Fetching RSS feed from ${RSS_URL}`);
        feed = await rssParser.parseURL(RSS_URL);
    } catch (err) {
        log.error(`Failed to fetch RSS feed: ${err.message}`);
        process.exit(1);
    }

    const now = new Date();
    const entries = feed.items;
    log.info(`Found ${entries.length} entries in RSS feed.`);

    for (const item of entries) {
        const title = item.title;
        const parsed = parser(title);
        
        if (!parsed || !parsed.show) {
            log.warn(`Could not parse title: ${title}`);
            continue;
        }

        const { show, season, episode } = parsed;
        const key = _.snakeCase(show);
		const candidate = {
			show,
			season,
			episode,
			title,
			last_seen: now.toISOString()
		};

		// Refresh recency on every sighting, but only replace the stored episode if this is newer.
		if (isNewerEpisode(candidate, db[key])) {
			log.debug(`${db[key] ? 'Updating' : 'Adding'} latest entry for: ${key}`);
			db[key] = candidate;
		} else if (db[key]) {
			db[key].last_seen = now.toISOString();
        }
    }

    // Eviction
    const cutoff = new Date(now.getTime() - maxDays * 24 * 60 * 60 * 1000);
    let evictedCount = 0;
    for (const key in db) {
        const lastSeen = new Date(db[key].last_seen);
        if (lastSeen < cutoff) {
            delete db[key];
            evictedCount++;
        }
    }

    if (evictedCount > 0) {
        log.info(`Evicted ${evictedCount} old entries.`);
    }

    try {
        fs.writeFileSync(DB_PATH, JSON.stringify(db, null, 2));
        log.info(`Database updated successfully. Total entries: ${Object.keys(db).length}`);
    } catch (err) {
        log.error(`Failed to write database file: ${err.message}`);
        process.exit(1);
    }
}

run().catch(err => {
    log.error(`Unhandled error: ${err.message}`);
    process.exit(1);
});