ani-auto 1.4.3 → 2.0.0

package/anime/index.js

@@ -0,0 +1,139 @@
+/**
+ * AnimePahe API - Node.js Library
+ * ================================
+ * This file serves as the entry point for using animepahe-api as a library.
+ * 
+ * Install: npm install github:ElijahCodes12345/animepahe-api
+ * 
+ * Usage:
+ *   const animepahe = require('animepahe-api');
+ *   const results = await animepahe.search('Naruto');
+ */
+
+// Core Scraper (Singleton)
+const Animepahe = require('./scrapers/animepahe');
+
+// Models (Business Logic)
+const HomeModel = require('./models/homeModel');
+const AnimeInfoModel = require('./models/animeInfoModel');
+const AnimeListModel = require('./models/animeListModel');
+const PlayModel = require('./models/playModel');
+const QueueModel = require('./models/queueModel');
+
+// Config Utility (for setting cookies, base URL, etc.)
+const Config = require('./utils/config');
+
+/**
+ * Initialize the library.
+ * Call this once before using any scraping functions if you need to refresh cookies.
+ * @returns {Promise<boolean>}
+ */
+async function initialize() {
+    return Animepahe.initialize();
+}
+
+/**
+ * Search for anime by title.
+ * @param {string} query - The search term
+ * @param {number} [page=1] - Page number for pagination
+ * @returns {Promise<object>} - Search results
+ */
+async function search(query, page = 1) {
+    return HomeModel.searchAnime(query, page);
+}
+
+/**
+ * Get currently airing anime.
+ * @param {number} [page=1] - Page number for pagination
+ * @returns {Promise<object>} - Airing anime list
+ */
+async function getAiring(page = 1) {
+    return HomeModel.getAiringAnime(page);
+}
+
+/**
+ * Get detailed information about an anime.
+ * @param {string} animeId - The AnimePahe session ID (e.g., "boruto-naruto-next-generations")
+ * @returns {Promise<object>} - Anime details
+ */
+async function getInfo(animeId) {
+    return AnimeInfoModel.getAnimeInfo(animeId);
+}
+
+/**
+ * Get episode releases for an anime.
+ * @param {string} animeId - The AnimePahe session ID
+ * @param {string} [sort='episode_desc'] - Sort order
+ * @param {number} [page=1] - Page number
+ * @returns {Promise<object>} - Episode list
+ */
+async function getReleases(animeId, sort = 'episode_desc', page = 1) {
+    return AnimeInfoModel.getAnimeReleases(animeId, sort, page);
+}
+
+/**
+ * Get streaming links for a specific episode.
+ * This is the core function for video extraction.
+ * @param {string} animeId - The AnimePahe session ID
+ * @param {string} episodeId - The episode session ID
+ * @param {boolean} [includeDownloads=true] - Whether to include download links
+ * @returns {Promise<object>} - Streaming sources with m3u8 URLs
+ */
+async function getStreamingLinks(animeId, episodeId, includeDownloads = true) {
+    return PlayModel.getStreamingLinks(animeId, episodeId, includeDownloads);
+}
+
+/**
+ * Get direct download link from a pahewin URL.
+ * @param {string} url - The pahewin download page URL
+ * @returns {Promise<object>} - Direct download URL
+ */
+async function getDownloadLink(url) {
+    return PlayModel.getDownloadLinks(url);
+}
+
+/**
+ * Get the anime list (A-Z index).
+ * @param {string} [tab] - Filter by first letter (e.g., 'A', 'B', '#')
+ * @param {string} [tag1] - Optional genre/tag filter
+ * @param {string} [tag2] - Optional second tag filter
+ * @returns {Promise<object>} - Anime list
+ */
+async function getAnimeList(tab, tag1, tag2) {
+    return AnimeListModel.getAnimeList(tab, tag1, tag2);
+}
+
+/**
+ * Get the queue (upcoming releases).
+ * @returns {Promise<object>} - Queue data
+ */
+async function getQueue() {
+    return QueueModel.getQueue();
+}
+
+// Export everything
+module.exports = {
+    // High-level API (Recommended)
+    initialize,
+    search,
+    getAiring,
+    getInfo,
+    getReleases,
+    getStreamingLinks,
+    getDownloadLink,
+    getAnimeList,
+    getQueue,
+    
+    // Low-level access (Advanced)
+    Animepahe,        // Raw scraper singleton
+    Config,           // Configuration utility
+    
+    // Models (for direct access if needed)
+    models: {
+        HomeModel,
+        AnimeInfoModel,
+        AnimeListModel,
+        PlayModel,
+        QueueModel
+    }
+};

package/anime/middleware/cache.js

@@ -0,0 +1,64 @@
+const redis = require('../utils/redis');
+const diskCache = require('../utils/diskCache');
+
+const cache = (duration) => async (req, res, next) => {
+    try {
+        // Build a normalized cache key: path + sorted query params
+        let key = req.path;
+        const queryKeys = Object.keys(req.query);
+        if (queryKeys.length > 0) {
+            const sortedQuery = queryKeys
+                .sort()
+                .map(k => `${encodeURIComponent(k)}=${encodeURIComponent(req.query[k])}`)
+                .join('&');
+            key += `?${sortedQuery}`;
+        }
+
+        // Try Redis first (if enabled)
+        if (redis.enabled) {
+            const cachedResponse = await redis.get(key);
+            if (cachedResponse) {
+                console.log(`[Cache] ✅ Redis HIT: ${key.substring(0, 60)}...`);
+                return res.json(JSON.parse(cachedResponse));
+            }
+        }
+
+        // Fallback to disk cache when Redis is disabled or miss
+        if (!redis.enabled) {
+            const diskCached = await diskCache.get(key);
+            if (diskCached !== null) {
+                console.log(`[Cache] ✅ Disk HIT: ${key.substring(0, 60)}...`);
+                return res.json(diskCached);
+            }
+        }
+
+        // No cache hit — proceed and cache the result
+        const originalJson = res.json;
+
+        res.json = async function(data) {
+            // Never cache non-success responses.
+            if (res.statusCode < 200 || res.statusCode >= 300) {
+                return originalJson.call(this, data);
+            }
+
+            // Cache in Redis if enabled
+            if (redis.enabled) {
+                await redis.setEx(key, duration, JSON.stringify(data));
+            }
+
+            // Always cache to disk as fallback (even if Redis is enabled — double layer)
+            if (!redis.enabled) {
+                await diskCache.set(key, data, duration);
+            }
+
+            return originalJson.call(this, data);
+        };
+
+        next();
+    } catch (error) {
+        console.error('Cache error:', error.message);
+        next();
+    }
+};
+
+module.exports = cache;

package/anime/middleware/errorHandler.js

@@ -0,0 +1,33 @@
+class CustomError extends Error {
+  constructor(message, statusCode = 500) {
+    super(message);
+    this.name = "CustomError";
+    this.statusCode = statusCode;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+const errorHandler = (err, req, res, next) => {
+  // Check err.statusCode first (CustomError sets this correctly)
+  // before falling back to err.response?.status for HTTP errors
+  const statusCode = err.statusCode || err.response?.status || 500;
+  const message = err.message || "Something went wrong";
+
+  console.error(`Error: ${message} (Status Code: ${statusCode})`);
+
+  const response = {
+    status: statusCode,
+    message: message,
+  };
+
+  if (process.env.NODE_ENV === "development") {
+    response.stack = err.stack;
+  }
+
+  res.status(statusCode).json(response);
+};
+
+module.exports = {
+  CustomError,
+  errorHandler,
+};

package/anime/middleware/rateLimiter.js

@@ -0,0 +1,73 @@
+const { redisClient, get, setEx, enabled } = require('../utils/redis');
+
+const RATE_LIMIT_MAX = parseInt(process.env.RATE_LIMIT_MAX || '100'); // requests per window
+const RATE_LIMIT_WINDOW = parseInt(process.env.RATE_LIMIT_WINDOW || '900'); // seconds (15 minutes)
+const RATE_LIMIT_SECRET = process.env.RATE_LIMIT_SECRET; // Only enable if this secret is set
+const IS_SERVERLESS = !!(process.env.VERCEL || process.env.NETLIFY || process.env.AWS_LAMBDA_FUNCTION_NAME);
+
+const rateLimiter = async (req, res, next) => {
+    //rate limiting if both the secret is set AND Redis is enabled
+    if (!RATE_LIMIT_SECRET || !enabled) {
+        // Skip rate limiting if no secret is set or Redis is not enabled
+        if (!enabled) {
+            console.warn('Redis not enabled, skipping rate limiting');
+        }
+        return next();
+    }
+
+    // Skip rate limiting for health checks and other internal routes. Routes doesn't exist tbf, just incase
+    if (req.path === '/api/health' || req.path === '/api/status') {
+        return next();
+    }
+
+    try {
+        const ip = req.headers['x-forwarded-for']?.split(',')[0]?.trim() || 
+                  req.headers['x-real-ip'] || 
+                  req.connection.remoteAddress || 
+                  req.socket.remoteAddress ||
+                  (req.connection.socket ? req.connection.socket.remoteAddress : null) ||
+                  'unknown';
+
+        if (ip === 'unknown') {
+            console.warn('Could not determine client IP address');
+            return next();
+        }
+
+        const key = `rate-limit:${ip}:${Math.floor(Date.now() / 1000 / RATE_LIMIT_WINDOW)}`;
+        const currentCount = await get(key);
+
+        if (currentCount === null) {
+            // First request in this window, set counter with expiration
+            await setEx(key, RATE_LIMIT_WINDOW, '1');
+            res.setHeader('X-RateLimit-Remaining', RATE_LIMIT_MAX - 1);
+            res.setHeader('X-RateLimit-Limit', RATE_LIMIT_MAX);
+            res.setHeader('X-RateLimit-Reset', new Date(Date.now() + RATE_LIMIT_WINDOW * 1000).toISOString());
+            return next();
+        }
+
+        const count = parseInt(currentCount);
+
+        if (count >= RATE_LIMIT_MAX) {
+            // Rate limit exceeded
+            res.status(429).json({
+                error: 'Rate limit exceeded. Please try again later.',
+                message: `Too many requests from this IP. Limit is ${RATE_LIMIT_MAX} requests per ${RATE_LIMIT_WINDOW} seconds.`,
+                retryAfter: RATE_LIMIT_WINDOW
+            });
+            return;
+        }
+
+        // Increment counter
+        await setEx(key, RATE_LIMIT_WINDOW, (count + 1).toString());
+        res.setHeader('X-RateLimit-Remaining', RATE_LIMIT_MAX - count - 1);
+        res.setHeader('X-RateLimit-Limit', RATE_LIMIT_MAX);
+        res.setHeader('X-RateLimit-Reset', new Date(Date.now() + RATE_LIMIT_WINDOW * 1000).toISOString());
+
+        return next();
+    } catch (error) {
+        console.error('Rate limiting error:', error);
+        return next();
+    }
+};
+
+module.exports = rateLimiter;

package/anime/models/animeInfoModel.js

@@ -0,0 +1,193 @@
+const cheerio = require('cheerio');
+const DataProcessor = require('../utils/dataProcessor');
+const Animepahe = require('../scrapers/animepahe');
+const { getJsVariable } = require('../utils/jsParser');
+const { CustomError } = require('../middleware/errorHandler');
+
+class AnimeInfoModel {
+    static async getAnimeInfo(animeId) {
+        const results = await Animepahe.getData("animeInfo", { animeId }, false);
+        
+        if (results?.data) {
+            return DataProcessor.processApiData(results);
+        }
+        
+        return this.scrapeInfoPage(results);
+    }
+    
+    static async getAnimeReleases(animeId, sort, page) {
+        const MAX_ATTEMPTS = 3;
+        let lastError = null;
+        let results = null;
+
+        for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+            try {
+                results = await Animepahe.getData("releases", { animeId, sort, page });
+                break;
+            } catch (error) {
+                lastError = error;
+                const status = error?.statusCode || error?.response?.status || 0;
+                const transient = status >= 500 || status === 0;
+                if (!transient || attempt === MAX_ATTEMPTS) {
+                    throw error;
+                }
+                console.warn(`[releases] transient failure for ${animeId} page=${page || 1} attempt=${attempt}/${MAX_ATTEMPTS}: ${error.message}`);
+                await new Promise((resolve) => setTimeout(resolve, 1000 * attempt));
+            }
+        }
+
+        if (!results) {
+            throw lastError || new CustomError('Failed to fetch anime releases', 503);
+        }
+
+        if (typeof results === 'object' && !results.data) {
+            results.data = [];
+        }
+
+        if (!results.data) {
+            throw new CustomError('No release data available', 404);
+        }
+
+        results._id = animeId;
+        return DataProcessor.processApiData(results, "releases");
+    }
+    
+    static async scrapeInfoPage(pageHtml) {
+        if (!pageHtml) {
+            throw new CustomError('Failed to fetch anime info page', 503);
+        }
+
+        const $ = cheerio.load(pageHtml);
+        const previewUrl = getJsVariable(pageHtml, 'preview');
+
+        const animeInfo = {
+            ids: {
+                animepahe_id: $('meta[name="id"]').attr('content') || null,
+                anidb: $('meta[name="anidb"]').attr('content') || null,
+                anilist: $('meta[name="anilist"]').attr('content') || null,
+                animePlanet: $('meta[name="anime-planet"]').attr('content') || null,
+                ann: $('meta[name="ann"]').attr('content') || null,
+                kitsu: $('meta[name="kitsu"]').attr('content') || null,
+                mal: $('meta[name="myanimelist"]').attr('content') || null
+            },
+            title: $('.title-wrapper h1 span').first().text().trim() || null,
+            image: $('.poster-wrapper .anime-poster img').attr('data-src') || null,
+            preview: previewUrl || null,
+            synopsis: $('.content-wrapper .anime-synopsis').text().trim() || null,
+            synonym: $('.anime-info p:contains("Synonyms:")').text().split('Synonyms:')[1]?.trim() || null,
+            japanese: $('.anime-info p:contains("Japanese:")').text().split('Japanese:')[1]?.trim() || null,
+            type: $('.anime-info p:contains("Type:") a').text().trim() || null,
+            episodes: $('.anime-info p:contains("Episodes:")').text().replace('Episodes:', "").trim() || null,
+            status: $('.anime-info p:contains("Status:") a').text().trim() || null,
+            duration: $('.anime-info p:contains("Duration:")').text().split('Duration:')[1]?.trim() || null,
+            aired: ($('.anime-info p:contains("Aired:")').text().split('Aired:')[1] || '')
+                .replace(/\s+/g, ' ')
+                .replace(/to\s+\?/, '')
+                .trim()
+                .replace(/(\w{3} \d{2}, \d{4}) +to +(\w{3} \d{2}, \d{4})/, '$1 to $2') || null,
+            season: $('.anime-info p:contains("Season:") a').text().trim() || null,
+            studio: $('.anime-info p:contains("Studio:")').text().split('Studio:')[1]?.trim() || null,
+            themes: $('.anime-info p:contains("Themes:")')
+                .find('a')
+                .map((i, el) => $(el).text().trim())
+                .get() || [],
+            demographic: $('.anime-info p:contains("Demographic:")')
+                .find('a')
+                .map((i, el) => $(el).text().trim())
+                .get() || [],
+            external_links: $('.anime-info p.external-links a').map((i, el) => ({
+                name: $(el).text(),
+                url: $(el).attr('href').replace(/^(http:)?\/\//, 'https://').replace(/^https:\/\/https:\/\//, 'https://')
+            })).get() || [],
+            genre: $('.anime-info div.anime-genre ul li a').map((i, el) => $(el).text()).get() || []
+        };
+
+        // Add relations and recommendations only if they exist
+        const relations = await this.scrapeRelationsSection($);
+        if (Object.keys(relations).length > 0) {
+            animeInfo.relations = relations;
+        }
+
+        const recommendations = await this.scrapeRecommendationsSection($);
+        if (recommendations.length > 0) {
+            animeInfo.recommendations = recommendations;
+        }
+
+        if (!animeInfo.title || !animeInfo.ids.animepahe_id) {
+            throw new CustomError('Failed to extract essential anime information', 500);
+        }
+
+        return animeInfo;
+    }
+
+    static async scrapeRelationsSection($) {
+        const relations = {};
+
+        $('.anime-relation > div.col-12.col-sm-6, .anime-relation > div.col-12.col-sm-12').each((i, section) => {
+            const $section = $(section);
+            const type = $section.find('h4 span').text().trim();
+
+            if (!type || $section.find('div.col-12.col-sm-12.mb-3, div.col-12.col-sm-6.mb-3').length === 0) return;
+            
+            relations[type] = [];
+            
+            $section.find('div.col-12.col-sm-12.mb-3, div.col-12.col-sm-6.mb-3').each((j, entry) => {
+                const $entry = $(entry);
+                const titleLink = $entry.find('h5 a');
+                
+                relations[type].push({
+                    title: titleLink.text().trim(),
+                    url: titleLink.attr('href'),
+                    session: titleLink.attr('href')?.replace('/anime/', ''),
+                    image: $entry.find('a img').attr('data-src'),
+                    type: ($entry.find('strong a').first().text().trim() || '?').replace(/\s+/g, ' '),
+                    episodes: ($entry.text().match(/(\d+)\s+Episode/) || [, '?'])[1],
+                    status: this.extractStatusFromText($entry.text()),
+                    season: $entry.find('a[href*="season"]').text().trim()
+                });
+            });
+
+            if (relations[type].length === 0) delete relations[type];
+        });
+      
+        return relations;
+    }
+
+    static async scrapeRecommendationsSection($) {
+        const recommendations = [];
+
+        $('div.tab-content.anime-recommendation > div.col-12.col-sm-6.mb-3').each((i, entry) => {
+            const $entry = $(entry);
+            const titleLink = $entry.find('h5 a');
+            
+            recommendations.push({
+                title: titleLink.text().trim(),
+                url: titleLink.attr('href'),
+                image: $entry.find('a img').attr('data-src'),
+                type: ($entry.find('strong a').first().text().trim() || '?').replace(/\s+/g, ' '),
+                episodes: ($entry.text().match(/(\d+)\s+Episode/) || [, '?'])[1],
+                status: this.extractStatusFromText($entry.text()),
+                season: $entry.find('a[href*="/season/"]').text().trim()
+            });
+        });
+
+        return recommendations;
+    }
+
+    static extractStatusFromText(text) {
+        const cleanText = text.replace(/\s+/g, ' ');
+        const episodeIndex = cleanText.toLowerCase().lastIndexOf('episode');
+        
+        if (episodeIndex === -1) return 'Unknown';
+        
+        const afterEpisode = cleanText.slice(episodeIndex + 'episode'.length).trim();
+        const parenStart = afterEpisode.indexOf('(');
+        const parenEnd = afterEpisode.indexOf(')');
+        
+        return (parenStart > -1 && parenEnd > parenStart)
+            ? afterEpisode.slice(parenStart + 1, parenEnd).trim()
+            : 'Unknown';
+    }
+}
+
+module.exports = AnimeInfoModel;

package/anime/models/animeListModel.js

@@ -0,0 +1,69 @@
+const cheerio = require("cheerio");
+const DataProcessor = require("../utils/dataProcessor");
+const Animepahe = require("../scrapers/animepahe");
+const { CustomError } = require("../middleware/errorHandler");
+
+class AnimeListModel {
+  static async getAnimeList(page, tab, genre) {
+    const results = await Animepahe.getData(
+      "animeList",
+      { page, tab, genre },
+      false,
+    );
+
+    if (results?.data) {
+      return DataProcessor.processApiData(results);
+    }
+
+    return this.scrapeAnimeListPage(results, tab);
+  }
+
+  static async scrapeAnimeListPage(pageHtml, tab) {
+    if (!pageHtml) {
+      throw new CustomError("Failed to fetch anime list page", 503);
+    }
+
+    const $ = cheerio.load(pageHtml);
+    const animeList = [];
+
+    const processPane = (pane) => {
+      $(pane)
+        .find("div.col-12.col-md-6")
+        .each((j, entry) => {
+          const $entry = $(entry);
+          const $link = $entry.find("a");
+          const $badge = $entry.find("span.badge");
+
+          animeList.push({
+            title: $link.attr("title") || $link.text().trim(),
+            url: $link.attr("href"),
+            type: $badge.length ? $badge.first().text().trim() : null,
+          });
+        });
+    };
+
+    if (typeof tab !== "undefined") {
+      const targetId =
+        tab === "#" || tab === "hash" ? "hash" : tab.toUpperCase();
+      const $pane = $(`div.tab-pane#${targetId}`);
+
+      if (!$pane.length) {
+        throw new CustomError(`No content found for tab: ${tab}`, 404);
+      }
+
+      processPane($pane);
+    } else {
+      $("div.tab-content div.tab-pane").each((i, pane) => {
+        processPane(pane);
+      });
+    }
+
+    if (animeList.length === 0) {
+      throw new CustomError("No anime entries found", 404);
+    }
+
+    return animeList;
+  }
+}
+
+module.exports = AnimeListModel;

package/anime/models/homeModel.js

@@ -0,0 +1,33 @@
+const DataProcessor = require('../utils/dataProcessor');
+const Config = require('../utils/config');
+const Animepahe = require('../scrapers/animepahe');
+const { CustomError } = require('../middleware/errorHandler');
+
+class HomeModel {
+    static async getAiringAnime(page) {
+        const results = await Animepahe.getData("airing", { page });
+
+        if (!results || !results.data) {
+            throw new CustomError('No airing anime data found', 404);
+        }
+
+        return DataProcessor.processApiData(results);
+    }
+
+    static async searchAnime(query, page) {
+        console.log(page);
+        if (!query) {
+            throw new CustomError('Search query is required', 400);
+        }
+
+        const results = await Animepahe.getData("search", { query, page });
+
+        if (!results || !results.data) {
+            throw new CustomError('No search results found', 404);
+        }
+
+        return DataProcessor.processApiData(results, 'search');
+    }
+}
+
+module.exports = HomeModel;