ani-auto 1.4.4 → 2.0.0

package/anime/utils/dataProcessor.js

@@ -0,0 +1,172 @@
+const Config = require("./config");
+
+class DataProcessor {
+  static processApiData(apiData, type = "airing", include = true) {
+    const items = apiData.data || [];
+
+    if (!Array.isArray(items)) {
+      console.error(
+        "Unexpected API response format:",
+        JSON.stringify(apiData).substring(0, 200),
+      );
+      throw new Error("Unexpected API response format");
+    }
+
+    let paginationInfo;
+    include
+      ? (paginationInfo = this._extractPaginationInfo(apiData, type))
+      : paginationInfo;
+
+    const dataProcessors = {
+      airing: this._processAiringData,
+      search: this._processSearchData,
+      releases: this._processReleaseData,
+      queue: this._processQueueData,
+    };
+
+    if (type === "releases") items._parentId = apiData._id;
+
+    const processor = dataProcessors[type] || this._processGenericData;
+
+    const processedData = processor(items);
+
+    if (processedData.length > 0) {
+      console.log(`Processed ${processedData.length} items of type: ${type}`);
+      // console.log("Sample:", processedData[0]);
+    }
+
+    return paginationInfo
+      ? { paginationInfo, data: processedData }
+      : { data: processedData };
+  }
+
+  static _extractPaginationInfo(apiData, type) {
+    if (!apiData) return {};
+
+    const {
+      _id,
+      total,
+      per_page,
+      current_page,
+      last_page,
+      next_page_url,
+      prev_page_url,
+      from,
+      to,
+    } = apiData;
+
+    const urlPrefix = _id ? `${_id}/${type}?` : `${type}?`;
+
+    const replaceUrl = (url) => {
+      if (!url) return url;
+      return url
+        .replace(new RegExp(`^(${Config.baseUrl}|/)`), Config.hostUrl)
+        .replace("api?", `api/${urlPrefix}`);
+    };
+
+    return {
+      ...(total != null && { total }),
+      ...(per_page != null && { perPage: per_page }),
+      ...(current_page != null && { currentPage: current_page }),
+      ...(last_page != null && { lastPage: last_page }),
+      ...(next_page_url != null && { nextPageUrl: replaceUrl(next_page_url) }),
+      ...(prev_page_url != null && { prevPageUrl: replaceUrl(prev_page_url) }),
+      ...(from != null && { from }),
+      ...(to != null && { to }),
+    };
+  }
+
+  static _processAiringData(items) {
+    return items.map((item) => ({
+      id: item.id || null,
+      anime_id: item.anime_id || null,
+      title: item.anime_title || null,
+      episode: item.episode || null,
+      episode2: item.episode2 || null,
+      edition: item.edition || null,
+      fansub: item.fansub || null,
+      image: item.snapshot || null,
+      disc: item.disc || null,
+      session: item.anime_session || null,
+      anime_session: item.anime_session || null,
+      episode_session: item.session || null,
+      link:
+        (item.anime_session ? `${Config.getUrl("animeInfo", { animeId: item.anime_session })}` : "") ||
+        null,
+      filler: item.filler || null,
+      created_at: item.created_at || null,
+      completed: item.completed || 1,
+    }));
+  }
+
+  static _processSearchData(items) {
+    return items.map((item) => ({
+      id: item.id || null,
+      title: item.title || null,
+      status: item.status || null,
+      type: item.type || null,
+      episodes: item.episodes || null,
+      score: item.score || null,
+      year: item.year || null,
+      season: item.season || null,
+      poster: item.poster || null,
+      session: item.session || null,
+      link:
+        (item.session ? `${Config.getUrl("animeInfo", item.session)}` : "") ||
+        null,
+    }));
+  }
+
+  static _processReleaseData(items) {
+    return items.map((item) => ({
+      id: item.id || null,
+      anime_id: item.anime_id || null,
+      episode: item.episode || null,
+      episode2: item.episode2 || null,
+      edition: item.edition || null,
+      title: item.title || null,
+      snapshot: item.snapshot || null,
+      disc: item.disc || null,
+      audio: item.audio || null,
+      duration: item.duration || null,
+      session: item.session || null,
+      link:
+        (item.session
+          ? `${Config.getUrl("play", items._parentId, item.session)}`
+          : "") || null,
+      filler: item.filler || null,
+      created_at: item.created_at || null,
+    }));
+  }
+
+  static _processQueueData(items) {
+    return items.map((item) => ({
+      title: item.title || null,
+      episode: item.episode || null,
+      resolution: item.resolution || null,
+      filesize: item.filesize || null,
+      fansub: item.fansub || null,
+      audio: item.audio || null,
+      progress: item.progress || null,
+      instant: item.instant || null,
+      current_duration: item.current_duration || null,
+      original: item.original_duration || null,
+      session: item.session || null,
+      published: item.published || null,
+    }));
+  }
+
+  // For unknown data types
+  static _processGenericData(items) {
+    return items.map((item) => {
+      // Clone the item but ensure no null property values
+      const processed = {};
+      Object.keys(item).forEach((key) => {
+        processed[key] = item[key] || null;
+      });
+      return processed;
+    });
+  }
+}
+
+module.exports = DataProcessor;

package/anime/utils/diskCache.js

@@ -0,0 +1,228 @@
+const fs = require("fs").promises;
+const path = require("path");
+const crypto = require("crypto");
+const { existsSync } = require("fs");
+
+// Cache directory — use /tmp for ephemeral storage (HF Spaces compatible)
+const CACHE_DIR = process.env.DISK_CACHE_DIR || path.join("/tmp", "anikuro-cache");
+
+// ─── Fix #3: Disk cache size limit ───
+// Prevents /tmp from filling up on HF Spaces (limited disk space).
+// When cache exceeds 200MB, oldest entries are evicted.
+const MAX_DISK_CACHE_BYTES = 200 * 1024 * 1024; // 200MB
+const CLEANUP_INTERVAL_MS = 10 * 60 * 1000; // 10 minutes
+
+let initialized = false;
+let cleanupIntervalStarted = false;
+
+/**
+ * Initialize the disk cache directory. Creates it if it doesn't exist.
+ */
+async function init() {
+  if (initialized) return;
+  try {
+    await fs.mkdir(CACHE_DIR, { recursive: true });
+    initialized = true;
+    console.log(`[Disk Cache] Initialized at: ${CACHE_DIR}`);
+  } catch (error) {
+    console.error("[Disk Cache] Failed to initialize cache directory:", error.message);
+    // Don't throw — cache is optional, app should still work
+  }
+}
+
+/**
+ * Hash a cache key into a safe filename.
+ */
+function hashKey(key) {
+  return crypto.createHash("md5").update(key).digest("hex");
+}
+
+/**
+ * Get a cached response from disk.
+ * Returns null if not found or expired.
+ */
+async function get(key) {
+  if (!initialized) await init();
+
+  try {
+    const filePath = path.join(CACHE_DIR, hashKey(key) + ".json");
+    if (!existsSync(filePath)) return null;
+
+    const raw = await fs.readFile(filePath, "utf8");
+    const entry = JSON.parse(raw);
+
+    // Check expiration
+    if (Date.now() - entry.timestamp > entry.duration * 1000) {
+      // Expired — delete it
+      await fs.unlink(filePath).catch(() => {});
+      return null;
+    }
+
+    console.log(`[Disk Cache] ✅ HIT: ${key.substring(0, 60)}...`);
+    return entry.data;
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      console.error("[Disk Cache] Get error:", error.message);
+    }
+    return null;
+  }
+}
+
+/**
+ * Set a cached response on disk with TTL.
+ * Evicts oldest entries when cache exceeds MAX_DISK_CACHE_BYTES.
+ */
+async function set(key, data, duration) {
+  if (!initialized) await init();
+
+  try {
+    const filePath = path.join(CACHE_DIR, hashKey(key) + ".json");
+    const entry = {
+      data,
+      timestamp: Date.now(),
+      duration, // in seconds
+    };
+
+    await fs.writeFile(filePath, JSON.stringify(entry), "utf8");
+    console.log(`[Disk Cache] 💾 SET: ${key.substring(0, 60)}...`);
+
+    // ─── Fix #3: Enforce max cache size ───
+    // After writing, check total size and evict oldest if over limit
+    try {
+      const files = await fs.readdir(CACHE_DIR);
+      const jsonFiles = files.filter(f => f.endsWith(".json"));
+
+      // Get file stats sorted by modification time (oldest first)
+      const fileStats = await Promise.all(
+        jsonFiles.map(async (file) => {
+          const filePath = path.join(CACHE_DIR, file);
+          const stat = await fs.stat(filePath);
+          return { path: filePath, mtime: stat.mtimeMs, size: stat.size };
+        })
+      );
+      fileStats.sort((a, b) => a.mtime - b.mtime);
+
+      let totalSize = fileStats.reduce((sum, f) => sum + f.size, 0);
+
+      // Evict oldest files until under limit
+      let evicted = 0;
+      for (const file of fileStats) {
+        if (totalSize <= MAX_DISK_CACHE_BYTES) break;
+        await fs.unlink(file.path).catch(() => {});
+        totalSize -= file.size;
+        evicted++;
+      }
+      if (evicted > 0) {
+        console.log(`[Disk Cache] Evicted ${evicted} entries (size: ${(totalSize / 1024 / 1024).toFixed(1)}MB)`);
+      }
+    } catch (err) {
+      // Non-fatal — cache failures should not break the app
+      console.error("[Disk Cache] Size enforcement error:", err.message);
+    }
+  } catch (error) {
+    console.error("[Disk Cache] Set error:", error.message);
+    // Don't throw — cache failures should not break the app
+  }
+}
+
+/**
+ * Delete a specific cache entry.
+ */
+async function del(key) {
+  if (!initialized) await init();
+
+  try {
+    const filePath = path.join(CACHE_DIR, hashKey(key) + ".json");
+    if (existsSync(filePath)) {
+      await fs.unlink(filePath);
+    }
+  } catch (error) {
+    console.error("[Disk Cache] Delete error:", error.message);
+  }
+}
+
+/**
+ * Clean all expired cache entries.
+ */
+async function cleanExpired() {
+  if (!initialized) await init();
+
+  try {
+    const files = await fs.readdir(CACHE_DIR);
+    let cleaned = 0;
+
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+
+      const filePath = path.join(CACHE_DIR, file);
+      try {
+        const raw = await fs.readFile(filePath, "utf8");
+        const entry = JSON.parse(raw);
+
+        if (Date.now() - entry.timestamp > entry.duration * 1000) {
+          await fs.unlink(filePath);
+          cleaned++;
+        }
+      } catch {
+        // Corrupted file — delete it
+        await fs.unlink(filePath).catch(() => {});
+        cleaned++;
+      }
+    }
+
+    if (cleaned > 0) {
+      console.log(`[Disk Cache] Cleaned ${cleaned} expired entries`);
+    }
+  } catch (error) {
+    console.error("[Disk Cache] Clean error:", error.message);
+  }
+}
+
+/**
+ * Get cache statistics (file count, total size).
+ */
+async function stats() {
+  if (!initialized) await init();
+
+  try {
+    const files = await fs.readdir(CACHE_DIR);
+    const jsonFiles = files.filter(f => f.endsWith(".json"));
+
+    let totalSize = 0;
+    for (const file of jsonFiles) {
+      const filePath = path.join(CACHE_DIR, file);
+      const stat = await fs.stat(filePath);
+      totalSize += stat.size;
+    }
+
+    return {
+      entries: jsonFiles.length,
+      totalSizeBytes: totalSize,
+      totalSizeMB: (totalSize / 1024 / 1024).toFixed(2),
+    };
+  } catch (error) {
+    return { entries: 0, totalSizeBytes: 0, totalSizeMB: "0.00" };
+  }
+}
+
+// Auto-clean expired entries on startup + periodic cleanup every 10 minutes
+init().then(() => {
+  cleanExpired();
+  if (!cleanupIntervalStarted) {
+    cleanupIntervalStarted = true;
+    setInterval(() => {
+      cleanExpired();
+    }, CLEANUP_INTERVAL_MS);
+  }
+});
+
+module.exports = {
+  init,
+  get,
+  set,
+  del,
+  cleanExpired,
+  stats,
+  CACHE_DIR,
+  MAX_DISK_CACHE_BYTES,
+};