@serifpersia/dango 3.6.7 → 3.6.9

package/server/dist/repositories/library.repository.js

@@ -1,94 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { getDrizzle } from '../db/drizzle.js';
-const LIBRARY_TABLES = [
-    'watchlist',
-    'watched_episodes',
-    'queue',
-    'shows_meta',
-    'dismissed_notifications',
-    'discovered_notifications',
-    'legacy_id_mapping',
-    'temp_show_ids',
-];
-const MANGA_LIBRARY_TABLES = ['manga_library', 'manga_progress'];
-const TV_LIBRARY_TABLES = ['tv_library', 'tv_progress'];
-const ASMR_LIBRARY_TABLES = ['asmr_library', 'asmr_progress'];
-async function countTables(db, tables) {
-    const counts = {};
-    for (const table of tables) {
-        try {
-            const rows = await getDrizzle(db).all(sql `SELECT COUNT(*) AS rows FROM ${sql.raw(`"${table}"`)}`);
-            counts[table] = rows[0]?.rows ?? 0;
-        }
-        catch {
-            counts[table] = 0;
-        }
-    }
-    return counts;
-}
-async function clearTables(db, tables) {
-    for (const table of tables) {
-        try {
-            await getDrizzle(db).run(sql `DELETE FROM ${sql.raw(`"${table}"`)}`);
-        }
-        catch {
-            // ignore
-        }
-    }
-}
-export function makeLibraryRepo(table) {
-    const t = sql.raw(`"${table}"`);
-    return {
-        getById: async (db, id) => {
-            const rows = await getDrizzle(db).all(sql `SELECT * FROM ${t} WHERE id = ${id}`);
-            return rows[0];
-        },
-        getAll: (db, status, limit, offset) => {
-            const q = sql `SELECT * FROM ${t}`;
-            if (status && status !== 'All') {
-                q.append(sql ` WHERE status = ${status}`);
-            }
-            q.append(sql ` ORDER BY updatedAt DESC`);
-            if (limit !== undefined && offset !== undefined) {
-                q.append(sql ` LIMIT ${limit} OFFSET ${offset}`);
-            }
-            return getDrizzle(db).all(q);
-        },
-        getCount: async (db, status) => {
-            if (status && status !== 'All') {
-                const rows = await getDrizzle(db).all(sql `SELECT COUNT(*) as total FROM ${t} WHERE status = ${status}`);
-                return rows[0]?.total || 0;
-            }
-            const rows = await getDrizzle(db).all(sql `SELECT COUNT(*) as total FROM ${t}`);
-            return rows[0]?.total || 0;
-        },
-        getIds: async (db) => {
-            const rows = await getDrizzle(db).all(sql `SELECT id FROM ${t}`);
-            return rows.map((r) => r.id);
-        },
-        updateStatus: (db, id, status) => getDrizzle(db).run(sql `
-      UPDATE ${t} SET status = ${status}, updatedAt = strftime('%s', 'now') WHERE id = ${id}`),
-        updateStatusMany: (db, ids, status) => {
-            if (ids.length === 0)
-                return Promise.resolve();
-            return getDrizzle(db).run(sql `
-      UPDATE ${t} SET status = ${status}, updatedAt = strftime('%s', 'now') WHERE id IN (${sql.join(ids.map((id) => sql `${id}`), sql `, `)})`);
-        },
-        delete: (db, id) => getDrizzle(db).run(sql `DELETE FROM ${t} WHERE id = ${id}`),
-        deleteMany: (db, ids) => {
-            if (ids.length === 0)
-                return Promise.resolve();
-            return getDrizzle(db).run(sql `DELETE FROM ${t} WHERE id IN (${sql.join(ids.map((id) => sql `${id}`), sql `, `)})`);
-        },
-    };
-}
-export const LibraryRepository = {
-    countAll: (db) => countTables(db, LIBRARY_TABLES),
-    clearAll: (db) => clearTables(db, LIBRARY_TABLES),
-    countManga: (db) => countTables(db, MANGA_LIBRARY_TABLES),
-    clearManga: (db) => clearTables(db, MANGA_LIBRARY_TABLES),
-    countTv: (db) => countTables(db, TV_LIBRARY_TABLES),
-    clearTv: (db) => clearTables(db, TV_LIBRARY_TABLES),
-    countAsmr: (db) => countTables(db, ASMR_LIBRARY_TABLES),
-    clearAsmr: (db) => clearTables(db, ASMR_LIBRARY_TABLES),
-};

package/server/dist/repositories/mal-cache.repository.js

@@ -1,52 +0,0 @@
-import { DatabaseSync } from 'node:sqlite';
-import fs from 'fs';
-import path from 'path';
-import { CONFIG } from '../config.js';
-import { DatabaseWrapper } from '../db.js';
-import { dbGet, dbRun } from '../utils/db-utils.js';
-export const MAL_CACHE_MAX_ROWS = 5000;
-const DEFAULT_TTL_SECONDS = 6 * 3600;
-function cacheFile() {
-    return path.join(CONFIG.ROOT, CONFIG.IS_DEV ? 'mal-cache.dev.db' : 'mal-cache.db');
-}
-let handle = null;
-function db() {
-    if (!handle) {
-        const file = cacheFile();
-        fs.mkdirSync(path.dirname(file), { recursive: true });
-        handle = new DatabaseWrapper(file, new DatabaseSync(file));
-        dbRun(handle, `CREATE TABLE IF NOT EXISTS mal_cache (key TEXT PRIMARY KEY, payload TEXT NOT NULL, fetched_at TEXT NOT NULL, expires_at TEXT NOT NULL)`);
-    }
-    return handle;
-}
-export function malCacheGet(key) {
-    const row = dbGet(db(), 'SELECT payload, fetched_at AS fetchedAt, expires_at AS expiresAt FROM mal_cache WHERE key = ?', [key]);
-    if (!row)
-        return null;
-    return { payload: row.payload, fresh: Date.now() < Date.parse(row.expiresAt) };
-}
-export function malCachePut(key, payload, ttlSeconds = DEFAULT_TTL_SECONDS) {
-    const database = db();
-    const now = new Date();
-    dbRun(database, 'INSERT OR REPLACE INTO mal_cache (key, payload, fetched_at, expires_at) VALUES (?, ?, ?, ?)', [key, payload, now.toISOString(), new Date(now.getTime() + ttlSeconds * 1000).toISOString()]);
-    const count = dbGet(database, 'SELECT COUNT(*) AS rows FROM mal_cache')?.rows ?? 0;
-    if (count < MAL_CACHE_MAX_ROWS)
-        return;
-    malCachePruneExpired();
-    const remaining = dbGet(database, 'SELECT COUNT(*) AS rows FROM mal_cache')?.rows ?? 0;
-    if (remaining < MAL_CACHE_MAX_ROWS)
-        return;
-    dbRun(database, `DELETE FROM mal_cache WHERE key NOT IN (SELECT key FROM mal_cache ORDER BY fetched_at DESC LIMIT ${MAL_CACHE_MAX_ROWS})`);
-}
-export function malCachePruneExpired() {
-    const now = new Date().toISOString();
-    const row = dbGet(db(), 'SELECT COUNT(*) AS rows FROM mal_cache WHERE expires_at < ?', [now]);
-    dbRun(db(), 'DELETE FROM mal_cache WHERE expires_at < ?', [now]);
-    return row?.rows ?? 0;
-}
-export function malCacheStore() {
-    return {
-        get: (key) => malCacheGet(key),
-        put: (key, payload, ttl) => malCachePut(key, payload, ttl),
-    };
-}

package/server/dist/repositories/manga.repository.js

@@ -1,95 +0,0 @@
-import { eq, inArray, sql } from 'drizzle-orm';
-import { getDrizzle } from '../db/drizzle.js';
-import { mangaLibrary, mangaProgress } from '../db/schema-manga.js';
-import { makeLibraryRepo } from './library.repository.js';
-export const MANGA_STATUSES = ['Reading', 'Completed', 'On-Hold', 'Dropped', 'Planned'];
-export function buildMangaId(provider, mangaId) {
-    return `${provider.toLowerCase()}:${mangaId}`;
-}
-export const MangaLibraryRepository = {
-    ...makeLibraryRepo('manga_library'),
-    upsert: (db, data) => getDrizzle(db).run(sql `
-      INSERT INTO manga_library (id, provider, mangaId, title, cover, status, author, altTitle, contentRating, anilistId, anilistIdSource, updatedAt)
-      VALUES (${data.id}, ${data.provider}, ${data.mangaId}, ${data.title}, ${data.cover}, ${data.status}, ${data.author || null}, ${data.altTitle || null}, ${data.contentRating || null}, ${data.anilistId ?? null}, ${data.anilistIdSource ?? null}, strftime('%s', 'now'))
-      ON CONFLICT(id) DO UPDATE SET
-         provider = COALESCE(NULLIF(EXCLUDED.provider, ''), manga_library.provider),
-         title = COALESCE(NULLIF(EXCLUDED.title, ''), manga_library.title),
-         cover = COALESCE(NULLIF(EXCLUDED.cover, ''), manga_library.cover),
-         status = COALESCE(NULLIF(EXCLUDED.status, ''), manga_library.status),
-         author = COALESCE(NULLIF(EXCLUDED.author, ''), manga_library.author),
-         altTitle = COALESCE(NULLIF(EXCLUDED.altTitle, ''), manga_library.altTitle),
-         contentRating = COALESCE(EXCLUDED.contentRating, manga_library.contentRating),
-         anilistId = COALESCE(EXCLUDED.anilistId, manga_library.anilistId),
-         anilistIdSource = COALESCE(EXCLUDED.anilistIdSource, manga_library.anilistIdSource),
-         updatedAt = strftime('%s', 'now')`),
-    setAnilistId: (db, id, anilistId, source) => source
-        ? getDrizzle(db)
-            .update(mangaLibrary)
-            .set({ anilistId, anilistIdSource: source })
-            .where(eq(mangaLibrary.id, id))
-        : getDrizzle(db).update(mangaLibrary).set({ anilistId }).where(eq(mangaLibrary.id, id)),
-    touchProgress: (db, id, progress) => getDrizzle(db).run(sql `
-      UPDATE manga_library SET lastChapterId = ${progress.chapterId}, lastChapterNumber = ${progress.chapterNumber}, lastPage = ${progress.page}, updatedAt = strftime('%s', 'now') WHERE id = ${id}`),
-    setProgressPointer: (db, id, chapterNumber) => getDrizzle(db).run(sql `
-      UPDATE manga_library SET lastChapterNumber = ${chapterNumber}, updatedAt = strftime('%s', 'now') WHERE id = ${id}`),
-};
-export const MangaProgressRepository = {
-    getByManga: (db, mangaId) => getDrizzle(db).all(sql `
-      SELECT mangaId, chapterId, chapterNumber, page, pageCount, updatedAt FROM manga_progress WHERE mangaId = ${mangaId} ORDER BY updatedAt DESC`),
-    getChapter: async (db, mangaId, chapterId) => {
-        const rows = await getDrizzle(db).all(sql `
-      SELECT mangaId, chapterId, chapterNumber, page, pageCount, updatedAt FROM manga_progress WHERE mangaId = ${mangaId} AND chapterId = ${chapterId}`);
-        return rows[0];
-    },
-    getLatest: async (db, mangaId) => {
-        const rows = await getDrizzle(db).all(sql `
-      SELECT mangaId, chapterId, chapterNumber, page, pageCount, updatedAt FROM manga_progress WHERE mangaId = ${mangaId} ORDER BY updatedAt DESC LIMIT 1`);
-        return rows[0];
-    },
-    upsert: (db, data) => getDrizzle(db).run(sql `
-      INSERT INTO manga_progress (mangaId, chapterId, chapterNumber, page, pageCount, title, cover, provider, altTitle, contentRating, updatedAt)
-      VALUES (${data.mangaId}, ${data.chapterId}, ${data.chapterNumber}, ${data.page}, ${data.pageCount}, ${data.title ?? null}, ${data.cover ?? null}, ${data.provider ?? null}, ${data.altTitle ?? null}, ${data.contentRating ?? null}, strftime('%s', 'now'))
-      ON CONFLICT(mangaId, chapterId) DO UPDATE SET
-         chapterNumber = COALESCE(NULLIF(EXCLUDED.chapterNumber, ''), manga_progress.chapterNumber),
-         page = EXCLUDED.page,
-         pageCount = EXCLUDED.pageCount,
-         title = COALESCE(EXCLUDED.title, manga_progress.title),
-         cover = COALESCE(EXCLUDED.cover, manga_progress.cover),
-         provider = COALESCE(EXCLUDED.provider, manga_progress.provider),
-         altTitle = COALESCE(EXCLUDED.altTitle, manga_progress.altTitle),
-         contentRating = COALESCE(EXCLUDED.contentRating, manga_progress.contentRating),
-         updatedAt = strftime('%s', 'now')`),
-    deleteByManga: (db, mangaId) => getDrizzle(db).delete(mangaProgress).where(eq(mangaProgress.mangaId, mangaId)),
-    deleteMany: (db, ids) => {
-        if (ids.length === 0)
-            return Promise.resolve();
-        return getDrizzle(db).delete(mangaProgress).where(inArray(mangaProgress.mangaId, ids));
-    },
-    deleteChapter: (db, mangaId, chapterId) => getDrizzle(db).run(sql `
-      DELETE FROM manga_progress WHERE mangaId = ${mangaId} AND chapterId = ${chapterId}`),
-    deleteSyntheticChapters: (db, mangaId, keepChapterId) => getDrizzle(db).run(sql `
-      DELETE FROM manga_progress WHERE mangaId = ${mangaId} AND chapterId LIKE 'anilist:ch:%' AND chapterId != ${keepChapterId}`),
-    moveSyntheticChapters: (db, fromMangaId, toMangaId) => getDrizzle(db).run(sql `
-      UPDATE manga_progress SET mangaId = ${toMangaId}, updatedAt = strftime('%s', 'now') WHERE mangaId = ${fromMangaId} AND chapterId LIKE 'anilist:ch:%'`),
-    getContinueReading: (db, limit) => {
-        const limitClause = typeof limit === 'number' ? `LIMIT ${limit}` : '';
-        return getDrizzle(db).all(sql `
-      SELECT p.mangaId as id,
-             COALESCE(l.mangaId, SUBSTR(p.mangaId, INSTR(p.mangaId, ':') + 1)) as mangaId,
-             COALESCE(l.provider, p.provider) as provider,
-             COALESCE(l.title, p.title) as title, COALESCE(l.cover, p.cover) as cover,
-             COALESCE(l.author, '') as author, COALESCE(l.altTitle, p.altTitle) as altTitle,
-             COALESCE(l.contentRating, p.contentRating) as contentRating,
-             l.status as watchlistStatus,
-             p.chapterId, p.chapterNumber, p.page, p.pageCount, p.updatedAt as progressAt
-      FROM (
-        SELECT *, ROW_NUMBER() OVER (PARTITION BY mangaId ORDER BY updatedAt DESC) as rn
-        FROM manga_progress
-      ) p
-      LEFT JOIN manga_library l ON p.mangaId = l.id
-      WHERE p.rn = 1
-        AND (l.status IS NULL OR l.status = 'Reading')
-      ORDER BY p.updatedAt DESC
-      ${sql.raw(limitClause)}`);
-    },
-};

package/server/dist/repositories/notifications.repository.js

@@ -1,60 +0,0 @@
-import { and, eq, sql } from 'drizzle-orm';
-import { getDrizzle } from '../db/drizzle.js';
-import { discoveredNotifications, dismissedNotifications } from '../db/schema-anime.js';
-export const NotificationsRepository = {
-    getDismissedByShow: (db, showId) => getDrizzle(db).all(sql `SELECT episodeNumber FROM dismissed_notifications WHERE showId = ${showId}`),
-    getDiscoveredByShow: (db, showId) => getDrizzle(db).all(sql `SELECT episodeNumber FROM discovered_notifications WHERE showId = ${showId}`),
-    addDiscovered: (db, showId, episodeNumber) => getDrizzle(db)
-        .insert(discoveredNotifications)
-        .values({ showId, episodeNumber })
-        .onConflictDoNothing(),
-    addDismissed: (db, showId, episodeNumber) => getDrizzle(db)
-        .insert(dismissedNotifications)
-        .values({ showId, episodeNumber })
-        .onConflictDoNothing(),
-    dismissFromDiscovered: (db, showId) => {
-        if (showId) {
-            return getDrizzle(db).run(sql `
-        INSERT OR IGNORE INTO dismissed_notifications (showId, episodeNumber) SELECT showId, episodeNumber FROM discovered_notifications WHERE showId = ${showId}`);
-        }
-        return getDrizzle(db).run(sql `
-      INSERT OR IGNORE INTO dismissed_notifications (showId, episodeNumber) SELECT showId, episodeNumber FROM discovered_notifications`);
-    },
-    deleteByShow: (db, showId) => Promise.all([
-        getDrizzle(db)
-            .delete(dismissedNotifications)
-            .where(eq(dismissedNotifications.showId, showId)),
-        getDrizzle(db)
-            .delete(discoveredNotifications)
-            .where(eq(discoveredNotifications.showId, showId)),
-    ]),
-    deleteSpecificDismissed: (db, showId, episodeNumber) => getDrizzle(db)
-        .delete(dismissedNotifications)
-        .where(and(eq(dismissedNotifications.showId, showId), eq(dismissedNotifications.episodeNumber, episodeNumber))),
-    deleteDiscovered: (db, showId, episodeNumber) => getDrizzle(db)
-        .delete(discoveredNotifications)
-        .where(and(eq(discoveredNotifications.showId, showId), eq(discoveredNotifications.episodeNumber, episodeNumber))),
-    cleanupWatchedNotifications: (db) => Promise.all([
-        getDrizzle(db).run(sql `
-        DELETE FROM dismissed_notifications WHERE EXISTS (SELECT 1 FROM watched_episodes we WHERE we.showId = dismissed_notifications.showId AND we.episodeNumber = dismissed_notifications.episodeNumber)`),
-        getDrizzle(db).run(sql `
-        DELETE FROM discovered_notifications WHERE EXISTS (SELECT 1 FROM watched_episodes we WHERE we.showId = discovered_notifications.showId AND we.episodeNumber = discovered_notifications.episodeNumber)`),
-    ]),
-    hasAnyDiscovered: async (db) => {
-        const rows = await getDrizzle(db).all(sql `SELECT COUNT(*) as count FROM discovered_notifications`);
-        return (rows[0]?.count || 0) > 0;
-    },
-    hasActiveNotifications: async (db) => {
-        const rows = await getDrizzle(db).all(sql `
-      SELECT COUNT(*) as count FROM discovered_notifications dn
-      WHERE NOT EXISTS (
-        SELECT 1 FROM dismissed_notifications dn2
-        WHERE dn2.showId = dn.showId AND dn2.episodeNumber = dn.episodeNumber
-      )
-      AND NOT EXISTS (
-        SELECT 1 FROM watched_episodes we
-        WHERE we.showId = dn.showId AND we.episodeNumber = dn.episodeNumber
-      )`);
-        return (rows[0]?.count || 0) > 0;
-    },
-};

package/server/dist/repositories/queue.repository.js

@@ -1,72 +0,0 @@
-import { and, eq, sql } from 'drizzle-orm';
-import { getDrizzle } from '../db/drizzle.js';
-import { queue } from '../db/schema-anime.js';
-export const QueueRepository = {
-    getAll: (db) => getDrizzle(db).all(sql `
-      SELECT
-        q.id,
-        q.showId,
-        q.episodeNumber,
-        q.queue_order,
-        COALESCE(NULLIF(sm.name, ''), w.name) as name,
-        COALESCE(NULLIF(sm.thumbnail, ''), NULLIF(w.thumbnail, ''), '') as thumbnail,
-        COALESCE(NULLIF(sm.nativeName, ''), w.nativeName) as nativeName,
-        COALESCE(NULLIF(sm.englishName, ''), w.englishName) as englishName,
-        COALESCE(NULLIF(sm.type, ''), w.type) as type
-      FROM queue q
-      LEFT JOIN shows_meta sm ON q.showId = sm.id
-      LEFT JOIN watchlist w ON q.showId = w.id
-      ORDER BY q.queue_order ASC, q.id ASC`),
-    getByEpisode: async (db, showId, episodeNumber) => {
-        const rows = await getDrizzle(db).all(sql `SELECT * FROM queue WHERE showId = ${showId} AND episodeNumber = ${episodeNumber}`);
-        return rows[0];
-    },
-    getByShow: (db, showId) => getDrizzle(db).all(sql `SELECT * FROM queue WHERE showId = ${showId} ORDER BY queue_order ASC`),
-    getMaxOrder: async (db) => {
-        const rows = await getDrizzle(db).all(sql `SELECT COALESCE(MAX(queue_order), -1) as maxOrder FROM queue`);
-        return rows[0]?.maxOrder ?? -1;
-    },
-    addToEnd: (db, showId, episodeNumber) => getDrizzle(db).run(sql `
-      INSERT INTO queue (showId, episodeNumber, queue_order) VALUES
-      (${showId}, ${episodeNumber}, (SELECT COALESCE(MAX(queue_order), -1) + 1 FROM queue))`),
-    removeEpisode: (db, showId, episodeNumber) => getDrizzle(db)
-        .delete(queue)
-        .where(and(eq(queue.showId, showId), eq(queue.episodeNumber, episodeNumber))),
-    addManyToEnd: async (db, episodes) => {
-        if (episodes.length === 0)
-            return;
-        let nextOrder = (await QueueRepository.getMaxOrder(db)) + 1;
-        for (const episode of episodes) {
-            const existing = await QueueRepository.getByEpisode(db, episode.showId, episode.episodeNumber);
-            if (existing)
-                continue;
-            await getDrizzle(db).insert(queue).values({
-                showId: episode.showId,
-                episodeNumber: episode.episodeNumber,
-                queueOrder: nextOrder,
-            });
-            nextOrder += 1;
-        }
-    },
-    removeMany: (db, showId, episodeNumbers) => {
-        if (episodeNumbers.length === 0)
-            return Promise.resolve();
-        return getDrizzle(db).run(sql `
-      DELETE FROM queue WHERE showId = ${showId} AND episodeNumber IN (${sql.join(episodeNumbers.map((e) => sql `${e}`), sql `, `)})`);
-    },
-    clear: (db) => getDrizzle(db).delete(queue),
-    reorder: (db, items) => Promise.all(items.map((item, index) => {
-        if (item.id !== undefined) {
-            return getDrizzle(db)
-                .update(queue)
-                .set({ queueOrder: index })
-                .where(eq(queue.id, item.id));
-        }
-        return getDrizzle(db)
-            .update(queue)
-            .set({ queueOrder: index })
-            .where(and(eq(queue.showId, item.showId ?? ''), eq(queue.episodeNumber, item.episodeNumber ?? '')));
-    })),
-    cleanupOrphanedShowsMeta: (db) => getDrizzle(db).run(sql `
-      DELETE FROM shows_meta WHERE id NOT IN (SELECT id FROM watchlist) AND id NOT IN (SELECT showId FROM queue)`),
-};

package/server/dist/repositories/settings.repository.js

@@ -1,30 +0,0 @@
-import { eq, sql } from 'drizzle-orm';
-import { getDrizzle } from '../db/drizzle.js';
-import { settings, watchlist } from '../db/schema-anime.js';
-export const SettingsRepository = {
-    getByKey: async (db, key) => {
-        const rows = await getDrizzle(db).all(sql `SELECT value FROM settings WHERE key = ${key}`);
-        return rows[0];
-    },
-    upsert: (db, key, value) => getDrizzle(db)
-        .insert(settings)
-        .values({ key, value })
-        .onConflictDoUpdate({ target: settings.key, set: { value } }),
-    deleteByKey: (db, key) => getDrizzle(db).delete(settings).where(eq(settings.key, key)),
-    readContinueFlags: async (db, ignoreKey, listOnlyKey) => {
-        const ignoreRow = await SettingsRepository.getByKey(db, ignoreKey);
-        const listOnlyRow = await SettingsRepository.getByKey(db, listOnlyKey);
-        return {
-            ignoreAdult: ignoreRow ? ignoreRow.value !== 'false' : true,
-            listOnly: listOnlyRow ? listOnlyRow.value === 'true' || listOnlyRow.value === '1' : false,
-        };
-    },
-    clearWatchlist: (db) => getDrizzle(db).delete(watchlist),
-    upsertWatchlistBatch: (db, shows) => {
-        if (shows.length === 0)
-            return Promise.resolve();
-        return getDrizzle(db).run(sql `
-      INSERT OR REPLACE INTO watchlist (id, name, thumbnail, status) VALUES
-      ${sql.join(shows.map((s) => sql `(${s.id}, ${s.name}, ${s.thumbnail ?? null}, ${s.status})`), sql `, `)}`);
-    },
-};

package/server/dist/repositories/shows-meta.repository.js

@@ -1,58 +0,0 @@
-import { eq, sql } from 'drizzle-orm';
-import { getDrizzle } from '../db/drizzle.js';
-import { showsMeta } from '../db/schema-anime.js';
-export const ShowsMetaRepository = {
-    getById: async (db, id) => {
-        const rows = await getDrizzle(db).all(sql `SELECT * FROM shows_meta WHERE id = ${id}`);
-        return rows[0];
-    },
-    getStatus: async (db, id) => {
-        const rows = await getDrizzle(db).all(sql `SELECT status FROM shows_meta WHERE id = ${id}`);
-        return rows[0]?.status;
-    },
-    upsert: (db, data) => {
-        const row = {
-            id: data.id,
-            name: data.name ?? null,
-            thumbnail: data.thumbnail ?? null,
-            nativeName: data.nativeName ?? null,
-            englishName: data.englishName ?? null,
-            genres: data.genres ?? null,
-            popularityScore: data.popularityScore ?? null,
-            status: data.status ?? null,
-            episodeCount: data.episodeCount ?? null,
-            type: data.type ?? null,
-            anilistId: data.anilistId ?? null,
-            isAdult: data.isAdult ?? null,
-            episodeDuration: data.episodeDuration ?? null,
-        };
-        return getDrizzle(db)
-            .insert(showsMeta)
-            .values(row)
-            .onConflictDoUpdate({
-            target: showsMeta.id,
-            set: {
-                name: sql `COALESCE(NULLIF(${row.name}, ''), ${showsMeta.name})`,
-                thumbnail: sql `COALESCE(NULLIF(${row.thumbnail}, ''), ${showsMeta.thumbnail})`,
-                nativeName: sql `COALESCE(NULLIF(${row.nativeName}, ''), ${showsMeta.nativeName})`,
-                englishName: sql `COALESCE(NULLIF(${row.englishName}, ''), ${showsMeta.englishName})`,
-                genres: sql `COALESCE(NULLIF(${row.genres}, ''), ${showsMeta.genres})`,
-                popularityScore: sql `COALESCE(${row.popularityScore}, ${showsMeta.popularityScore})`,
-                status: sql `COALESCE(NULLIF(${row.status}, ''), ${showsMeta.status})`,
-                episodeCount: sql `COALESCE(${row.episodeCount}, ${showsMeta.episodeCount})`,
-                type: sql `COALESCE(NULLIF(${row.type}, ''), ${showsMeta.type})`,
-                anilistId: sql `COALESCE(${row.anilistId}, ${showsMeta.anilistId})`,
-                isAdult: sql `COALESCE(${row.isAdult}, ${showsMeta.isAdult})`,
-                episodeDuration: sql `COALESCE(NULLIF(${row.episodeDuration}, 0), ${showsMeta.episodeDuration})`,
-            },
-        });
-    },
-    updateEpisodeCount: (db, id, episodeCount) => getDrizzle(db).update(showsMeta).set({ episodeCount }).where(eq(showsMeta.id, id)),
-    updateStatus: (db, id, status) => getDrizzle(db).update(showsMeta).set({ status }).where(eq(showsMeta.id, id)),
-    cleanupOrphanedMeta: (db) => getDrizzle(db).run(sql `
-      DELETE FROM shows_meta WHERE id NOT IN (SELECT id FROM watchlist) AND id NOT IN (SELECT showId FROM queue)`),
-    getShowIdsMissingMeta: (db) => getDrizzle(db).all(sql `
-      SELECT DISTINCT we.showId as id FROM watched_episodes we
-      LEFT JOIN shows_meta sm ON sm.id = we.showId
-      WHERE sm.thumbnail IS NULL OR TRIM(sm.thumbnail) = ''`),
-};

package/server/dist/repositories/temp-show-ids.repository.js

@@ -1,63 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { getDrizzle } from '../db/drizzle.js';
-import { tempShowIds } from '../db/schema-anime.js';
-import { TEMP_SHOW_ID_PREFIX } from '../lib/temp-ids.js';
-export const TempShowIdsRepository = {
-    getById: async (db, id) => {
-        const rows = await getDrizzle(db).all(sql `SELECT * FROM temp_show_ids WHERE id = ${id}`);
-        return rows[0];
-    },
-    getByProviderNative: async (db, provider, nativeId) => {
-        const rows = await getDrizzle(db).all(sql `SELECT * FROM temp_show_ids WHERE provider = ${provider} AND nativeId = ${nativeId}`);
-        return rows[0];
-    },
-    count: async (db) => {
-        const rows = await getDrizzle(db).all(sql `SELECT COUNT(*) as total FROM temp_show_ids`);
-        return rows[0]?.total || 0;
-    },
-    allocate: async (db, data) => {
-        const existing = await TempShowIdsRepository.getByProviderNative(db, data.provider, data.nativeId);
-        if (existing)
-            return existing;
-        const prefixLen = TEMP_SHOW_ID_PREFIX.length + 1;
-        const maxRows = await getDrizzle(db).all(sql `
-      SELECT MAX(CAST(SUBSTR(id, ${prefixLen}) AS INTEGER)) as maxId FROM temp_show_ids WHERE id LIKE ${`${TEMP_SHOW_ID_PREFIX}%`}`);
-        const next = (maxRows[0]?.maxId || 0) + 1;
-        const id = `${TEMP_SHOW_ID_PREFIX}${next}`;
-        try {
-            await getDrizzle(db)
-                .insert(tempShowIds)
-                .values({
-                id,
-                provider: data.provider,
-                nativeId: data.nativeId,
-                title: data.title,
-                thumbnail: data.thumbnail || '',
-                createdAt: Date.now(),
-            });
-        }
-        catch {
-            const winner = await TempShowIdsRepository.getByProviderNative(db, data.provider, data.nativeId);
-            if (winner)
-                return winner;
-            throw new Error('temp id allocation failed');
-        }
-        return (await TempShowIdsRepository.getById(db, id));
-    },
-    purge: async (db) => {
-        const total = await TempShowIdsRepository.count(db);
-        if (total === 0)
-            return 0;
-        const likePattern = `${TEMP_SHOW_ID_PREFIX}%`;
-        await getDrizzle(db).run(sql `DELETE FROM watchlist WHERE id LIKE ${likePattern}`);
-        await getDrizzle(db).run(sql `DELETE FROM watched_episodes WHERE showId LIKE ${likePattern}`);
-        await getDrizzle(db).run(sql `DELETE FROM queue WHERE showId LIKE ${likePattern}`);
-        await getDrizzle(db).run(sql `DELETE FROM shows_meta WHERE id LIKE ${likePattern}`);
-        await getDrizzle(db).run(sql `DELETE FROM dismissed_notifications WHERE showId LIKE ${likePattern}`);
-        await getDrizzle(db).run(sql `DELETE FROM discovered_notifications WHERE showId LIKE ${likePattern}`);
-        await getDrizzle(db).run(sql `
-      DELETE FROM legacy_id_mapping WHERE legacyId LIKE ${likePattern} OR numericId LIKE ${likePattern}`);
-        await getDrizzle(db).delete(tempShowIds);
-        return total;
-    },
-};

package/server/dist/repositories/tv.repository.js

@@ -1,93 +0,0 @@
-import { eq, inArray, sql } from 'drizzle-orm';
-import { getDrizzle } from '../db/drizzle.js';
-import { tvProgress } from '../db/schema-tv.js';
-import { makeLibraryRepo } from './library.repository.js';
-export const TV_STATUSES = ['Watching', 'Completed', 'On-Hold', 'Dropped', 'Planned'];
-export function buildTvId(mediaType, tmdbId) {
-    const t = String(mediaType).toLowerCase() === 'movie' ? 'movie' : 'tv';
-    return `${t}:${tmdbId}`;
-}
-export function normalizeTvMediaId(raw) {
-    const s = String(raw ?? '').trim();
-    const m = /^(movie|tv)[:-](\d+)$/i.exec(s);
-    if (m)
-        return `${m[1].toLowerCase()}:${m[2]}`;
-    return s;
-}
-export const TvLibraryRepository = {
-    ...makeLibraryRepo('tv_library'),
-    upsert: (db, data) => getDrizzle(db).run(sql `
-      INSERT INTO tv_library (id, tmdbId, mediaType, title, poster, backdrop, year, overview, status, adult, updatedAt)
-      VALUES (${data.id}, ${data.tmdbId}, ${data.mediaType}, ${data.title}, ${data.poster}, ${data.backdrop || null}, ${data.year || null}, ${data.overview || null}, ${data.status}, ${data.adult ? 1 : 0}, strftime('%s', 'now'))
-      ON CONFLICT(id) DO UPDATE SET
-         tmdbId = EXCLUDED.tmdbId,
-         mediaType = EXCLUDED.mediaType,
-         title = COALESCE(NULLIF(EXCLUDED.title, ''), tv_library.title),
-         poster = COALESCE(NULLIF(EXCLUDED.poster, ''), tv_library.poster),
-         backdrop = COALESCE(NULLIF(EXCLUDED.backdrop, ''), tv_library.backdrop),
-         year = COALESCE(NULLIF(EXCLUDED.year, ''), tv_library.year),
-         overview = COALESCE(NULLIF(EXCLUDED.overview, ''), tv_library.overview),
-         status = COALESCE(NULLIF(EXCLUDED.status, ''), tv_library.status),
-         adult = COALESCE(EXCLUDED.adult, tv_library.adult),
-         updatedAt = strftime('%s', 'now')`),
-    touchProgress: (db, id, progress) => getDrizzle(db).run(sql `
-      UPDATE tv_library SET lastSeason = ${progress.season}, lastEpisode = ${progress.episode}, updatedAt = strftime('%s', 'now') WHERE id = ${id}`),
-};
-export const TvProgressRepository = {
-    getByMedia: (db, mediaId) => getDrizzle(db).all(sql `
-      SELECT mediaId, season, episode, currentTime, duration, completed, updatedAt FROM tv_progress WHERE mediaId = ${mediaId} ORDER BY updatedAt DESC, rowid DESC`),
-    getEpisode: async (db, mediaId, season, episode) => {
-        const rows = await getDrizzle(db).all(sql `
-      SELECT mediaId, season, episode, currentTime, duration, completed, updatedAt FROM tv_progress WHERE mediaId = ${mediaId} AND season = ${season} AND episode = ${episode}`);
-        return rows[0];
-    },
-    getLatest: async (db, mediaId) => {
-        const rows = await getDrizzle(db).all(sql `
-      SELECT mediaId, season, episode, currentTime, duration, completed, updatedAt FROM tv_progress WHERE mediaId = ${mediaId} ORDER BY updatedAt DESC, rowid DESC LIMIT 1`);
-        return rows[0];
-    },
-    upsert: (db, data) => getDrizzle(db).run(sql `
-      INSERT INTO tv_progress (mediaId, season, episode, currentTime, duration, completed, title, poster, backdrop, year, overview, tmdbId, mediaType, adult, updatedAt)
-      VALUES (${data.mediaId}, ${data.season}, ${data.episode}, ${data.currentTime}, ${data.duration}, ${data.completed}, ${data.title ?? null}, ${data.poster ?? null}, ${data.backdrop ?? null}, ${data.year ?? null}, ${data.overview ?? null}, ${data.tmdbId ?? null}, ${data.mediaType ?? null}, ${data.adult ?? null}, strftime('%s', 'now'))
-      ON CONFLICT(mediaId, season, episode) DO UPDATE SET
-         currentTime = EXCLUDED.currentTime,
-         duration = EXCLUDED.duration,
-         completed = EXCLUDED.completed,
-         title = COALESCE(EXCLUDED.title, tv_progress.title),
-         poster = COALESCE(EXCLUDED.poster, tv_progress.poster),
-         backdrop = COALESCE(EXCLUDED.backdrop, tv_progress.backdrop),
-         year = COALESCE(EXCLUDED.year, tv_progress.year),
-         overview = COALESCE(EXCLUDED.overview, tv_progress.overview),
-         tmdbId = COALESCE(EXCLUDED.tmdbId, tv_progress.tmdbId),
-         mediaType = COALESCE(EXCLUDED.mediaType, tv_progress.mediaType),
-         adult = COALESCE(EXCLUDED.adult, tv_progress.adult),
-         updatedAt = strftime('%s', 'now')`),
-    deleteByMedia: (db, mediaId) => getDrizzle(db).delete(tvProgress).where(eq(tvProgress.mediaId, mediaId)),
-    deleteMany: (db, ids) => {
-        if (ids.length === 0)
-            return Promise.resolve();
-        return getDrizzle(db).delete(tvProgress).where(inArray(tvProgress.mediaId, ids));
-    },
-    deleteEpisode: (db, mediaId, season, episode) => getDrizzle(db).run(sql `
-      DELETE FROM tv_progress WHERE mediaId = ${mediaId} AND season = ${season} AND episode = ${episode}`),
-    getContinueWatching: (db, limit) => {
-        const limitClause = typeof limit === 'number' ? `LIMIT ${limit}` : '';
-        return getDrizzle(db).all(sql `
-      SELECT p.mediaId as id,
-             COALESCE(l.tmdbId, p.tmdbId, CAST(SUBSTR(REPLACE(p.mediaId, '-', ':'), INSTR(REPLACE(p.mediaId, '-', ':'), ':') + 1) AS INTEGER)) as tmdbId,
-             COALESCE(l.mediaType, p.mediaType, SUBSTR(REPLACE(p.mediaId, '-', ':'), 1, INSTR(REPLACE(p.mediaId, '-', ':'), ':') - 1)) as mediaType,
-             COALESCE(l.title, p.title) as title, COALESCE(l.poster, p.poster) as poster, COALESCE(l.backdrop, p.backdrop) as backdrop,
-             COALESCE(l.year, p.year) as year, COALESCE(l.overview, p.overview) as overview,
-             l.status as watchlistStatus, COALESCE(l.adult, p.adult) as adult,
-             p.season, p.episode, p.currentTime, p.duration, p.completed, p.updatedAt as progressAt
-      FROM (
-        SELECT *, rowid AS progressRowid, ROW_NUMBER() OVER (PARTITION BY mediaId ORDER BY updatedAt DESC, rowid DESC) as rn
-        FROM tv_progress
-      ) p
-      LEFT JOIN tv_library l ON p.mediaId = l.id
-      WHERE p.rn = 1
-        AND (l.status IS NULL OR l.status = 'Watching')
-      ORDER BY p.updatedAt DESC, p.progressRowid DESC
-      ${sql.raw(limitClause)}`);
-    },
-};