@serifpersia/dango 3.6.7 → 3.6.9

package/server/dist/repositories/watched-episodes.repository.js

@@ -1,82 +0,0 @@
-import { eq, sql } from 'drizzle-orm';
-import { getDrizzle } from '../db/drizzle.js';
-import { watchedEpisodes } from '../db/schema-anime.js';
-export const WatchedEpisodesRepository = {
-    getByShowAndEpisode: async (db, showId, episodeNumber) => {
-        const rows = await getDrizzle(db).all(sql `
-      SELECT currentTime, duration FROM watched_episodes WHERE showId = ${showId} AND episodeNumber = ${episodeNumber}`);
-        return rows[0];
-    },
-    getWatchedEpisodeNumbers: async (db, showId) => {
-        const rows = await getDrizzle(db).all(sql `SELECT episodeNumber FROM watched_episodes WHERE showId = ${showId}`);
-        return rows.map((r) => r.episodeNumber);
-    },
-    getByShow: (db, showId) => getDrizzle(db).all(sql `
-      SELECT showId, episodeNumber, currentTime, duration, watchedAt FROM watched_episodes WHERE showId = ${showId} ORDER BY CAST(episodeNumber AS REAL) ASC`),
-    getLatestResumeProgress: async (db, showId) => {
-        const rows = await getDrizzle(db).all(sql `
-      SELECT showId, episodeNumber, currentTime, duration, watchedAt
-      FROM watched_episodes
-      WHERE showId = ${showId} AND currentTime > 5 AND (duration <= 0 OR currentTime < duration * 0.8)
-      ORDER BY watchedAt DESC
-      LIMIT 1`);
-        return rows[0];
-    },
-    upsert: (db, data) => getDrizzle(db)
-        .insert(watchedEpisodes)
-        .values({
-        showId: data.showId,
-        episodeNumber: data.episodeNumber,
-        watchedAt: sql `CURRENT_TIMESTAMP`,
-        currentTime: data.currentTime,
-        duration: data.duration,
-    })
-        .onConflictDoUpdate({
-        target: [watchedEpisodes.showId, watchedEpisodes.episodeNumber],
-        set: {
-            watchedAt: sql `CURRENT_TIMESTAMP`,
-            currentTime: data.currentTime,
-            duration: data.duration,
-        },
-    }),
-    insertIfMissing: (db, data) => getDrizzle(db)
-        .insert(watchedEpisodes)
-        .values({
-        showId: data.showId,
-        episodeNumber: data.episodeNumber,
-        watchedAt: data.watchedAt ? sql `${data.watchedAt}` : sql `CURRENT_TIMESTAMP`,
-        currentTime: 0,
-        duration: 0,
-    })
-        .onConflictDoNothing(),
-    deleteByShow: (db, showId) => getDrizzle(db).delete(watchedEpisodes).where(eq(watchedEpisodes.showId, showId)),
-    getContinueWatching: (db, limit) => {
-        const limitClause = typeof limit === 'number' ? `LIMIT ${limit}` : '';
-        return getDrizzle(db).all(sql `
-      SELECT
-        we.showId as _id,
-        we.showId as id,
-        COALESCE(NULLIF(w.name, ''), sm.name) as name,
-        COALESCE(NULLIF(w.thumbnail, ''), NULLIF(sm.thumbnail, ''), '') as thumbnail,
-        COALESCE(NULLIF(w.nativeName, ''), sm.nativeName) as nativeName,
-        COALESCE(NULLIF(w.englishName, ''), sm.englishName) as englishName,
-        COALESCE(NULLIF(w.type, ''), sm.type) as type,
-        sm.episodeCount,
-        sm.type as smType,
-        sm.isAdult as isAdult,
-        w.status as watchlistStatus,
-        (SELECT COUNT(DISTINCT episodeNumber) FROM watched_episodes WHERE showId = we.showId) as watchedCount,
-        we.episodeNumber, we.currentTime, we.duration, we.watchedAt
-      FROM (
-        SELECT *, ROW_NUMBER() OVER(PARTITION BY showId ORDER BY (currentTime > 0 OR duration > 0) DESC, watchedAt DESC) as rn
-        FROM watched_episodes
-      ) we
-      LEFT JOIN watchlist w ON we.showId = w.id
-      LEFT JOIN shows_meta sm ON we.showId = sm.id
-      WHERE we.rn = 1
-        AND (w.status IS NULL OR w.status = 'Watching')
-        AND (w.id IS NOT NULL OR sm.id IS NOT NULL)
-      ORDER BY we.watchedAt DESC
-      ${sql.raw(limitClause)}`);
-    },
-};

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

@@ -1,60 +0,0 @@
-import { eq, inArray, sql } from 'drizzle-orm';
-import { getDrizzle } from '../db/drizzle.js';
-import { watchlist } from '../db/schema-anime.js';
-export const WatchlistRepository = {
-    getById: async (db, id) => {
-        const rows = await getDrizzle(db).all(sql `SELECT * FROM watchlist WHERE id = ${id}`);
-        return rows[0];
-    },
-    exists: async (db, id) => {
-        const rows = await getDrizzle(db).all(sql `SELECT EXISTS(SELECT 1 FROM watchlist WHERE id = ${id}) as inWatchlist`);
-        return !!(rows[0] && rows[0].inWatchlist);
-    },
-    getAll: (db, status, limit, offset) => {
-        const q = sql `SELECT * FROM watchlist`;
-        if (status && status !== 'All') {
-            q.append(sql ` WHERE status = ${status}`);
-        }
-        q.append(sql ` ORDER BY rowid DESC`);
-        if (limit !== undefined && offset !== undefined) {
-            q.append(sql ` LIMIT ${limit} OFFSET ${offset}`);
-        }
-        return getDrizzle(db).all(q);
-    },
-    getCount: async (db, status) => {
-        const q = sql `SELECT COUNT(*) as total FROM watchlist`;
-        if (status && status !== 'All') {
-            q.append(sql ` WHERE status = ${status}`);
-        }
-        const rows = await getDrizzle(db).all(q);
-        return rows[0]?.total || 0;
-    },
-    upsert: (db, data) => getDrizzle(db).run(sql `
-      INSERT INTO watchlist (id, name, thumbnail, status, nativeName, englishName, type) VALUES (${data.id}, ${data.name}, ${data.thumbnail}, ${data.status}, ${data.nativeName}, ${data.englishName}, ${data.type})
-      ON CONFLICT(id) DO UPDATE SET
-         name = COALESCE(NULLIF(EXCLUDED.name, ''), watchlist.name),
-         thumbnail = COALESCE(NULLIF(EXCLUDED.thumbnail, ''), watchlist.thumbnail),
-         status = COALESCE(NULLIF(EXCLUDED.status, ''), watchlist.status),
-         nativeName = COALESCE(NULLIF(EXCLUDED.nativeName, ''), watchlist.nativeName),
-         englishName = COALESCE(NULLIF(EXCLUDED.englishName, ''), watchlist.englishName),
-         type = COALESCE(NULLIF(EXCLUDED.type, ''), watchlist.type)`),
-    updateStatus: (db, id, status) => getDrizzle(db).update(watchlist).set({ status }).where(eq(watchlist.id, id)),
-    updateThumbnail: (db, id, thumbnail) => {
-        if (!thumbnail || thumbnail.trim() === '')
-            return Promise.resolve();
-        return getDrizzle(db).update(watchlist).set({ thumbnail }).where(eq(watchlist.id, id));
-    },
-    delete: (db, id) => getDrizzle(db).delete(watchlist).where(eq(watchlist.id, id)),
-    deleteMany: (db, ids) => {
-        if (ids.length === 0)
-            return Promise.resolve();
-        return getDrizzle(db).delete(watchlist).where(inArray(watchlist.id, ids));
-    },
-    updateStatusMany: (db, ids, status) => {
-        if (ids.length === 0)
-            return Promise.resolve();
-        return getDrizzle(db).update(watchlist).set({ status }).where(inArray(watchlist.id, ids));
-    },
-    getWatchingShows: (db) => getDrizzle(db).all(sql `SELECT id, name, thumbnail, nativeName, englishName FROM watchlist WHERE status = 'Watching'`),
-    getMissingThumbnails: (db) => getDrizzle(db).all(sql `SELECT id, name FROM watchlist WHERE thumbnail IS NULL OR TRIM(thumbnail) = ''`),
-};

package/server/dist/scripts/backfill-episode-duration.js

@@ -1,42 +0,0 @@
-import path from 'node:path';
-import { CONFIG } from '../config.js';
-import { DatabaseWrapper } from '../db.js';
-import { anilistRequest } from '../lib/anilist.js';
-import { dbAll, dbRun } from '../utils/db-utils.js';
-const BATCH_SIZE = 50;
-async function main() {
-    const dbName = CONFIG.IS_DEV ? CONFIG.DB_NAME_DEV : CONFIG.DB_NAME_PROD;
-    const db = await DatabaseWrapper.create(path.join(CONFIG.ROOT, dbName));
-    db.configure('busyTimeout', 10000);
-    const cols = dbAll(db, 'PRAGMA table_info(shows_meta)');
-    if (!cols.some((c) => c.name === 'episodeDuration')) {
-        db.run('ALTER TABLE shows_meta ADD COLUMN episodeDuration INTEGER');
-    }
-    const missing = dbAll(db, 'SELECT id, anilistId FROM shows_meta WHERE anilistId IS NOT NULL AND episodeDuration IS NULL');
-    if (missing.length === 0) {
-        console.log('Nothing to backfill.');
-        db.close();
-        return;
-    }
-    let updated = 0;
-    for (let i = 0; i < missing.length; i += BATCH_SIZE) {
-        const batch = missing.slice(i, i + BATCH_SIZE);
-        const res = await anilistRequest(`query ($ids: [Int]) { Page(perPage: ${BATCH_SIZE}) { media(id_in: $ids, type: ANIME) { id duration } } }`, { ids: batch.map((b) => b.anilistId) });
-        for (const m of res?.data?.Page?.media ?? []) {
-            if (!m.duration || m.duration <= 0)
-                continue;
-            const row = batch.find((b) => b.anilistId === m.id);
-            if (!row)
-                continue;
-            dbRun(db, 'UPDATE shows_meta SET episodeDuration = ? WHERE id = ?', [m.duration, row.id]);
-            updated++;
-        }
-        console.log(`Progress: ${Math.min(i + BATCH_SIZE, missing.length)}/${missing.length} (updated ${updated})`);
-    }
-    console.log(`Done. Updated ${updated} of ${missing.length} shows.`);
-    db.close();
-}
-main().catch((err) => {
-    console.error(err?.message || err);
-    process.exit(1);
-});

package/server/dist/sync-payload.js

@@ -1,91 +0,0 @@
-import path from 'path';
-import logger from './logger.js';
-import { CONFIG } from './config.js';
-import { dbAll, dbGet } from './utils/db-utils.js';
-import { isTempSyncRow } from './lib/temp-ids.js';
-const log = logger.child({ module: 'SyncPayload' });
-export const ANIME_SYNC_TABLES = [
-    'watchlist',
-    'watched_episodes',
-    'queue',
-    'settings',
-    'shows_meta',
-    'sync_metadata',
-    'dismissed_notifications',
-    'discovered_notifications',
-];
-export const MANGA_SYNC_TABLES = ['manga_library', 'manga_progress', 'sync_metadata'];
-export const TV_SYNC_TABLES = ['tv_library', 'tv_progress', 'sync_metadata'];
-export const ASMR_SYNC_TABLES = ['asmr_library', 'asmr_progress', 'sync_metadata'];
-export function readPayloadVersion(payload) {
-    const meta = payload.tables['sync_metadata'];
-    const row = meta?.find((r) => r.key === 'db_version');
-    const v = row?.value;
-    return typeof v === 'number' ? v : Number(v || payload.version || 0);
-}
-export function normalizePayload(input, tables, label) {
-    if (!input || typeof input !== 'object' || !('tables' in input)) {
-        throw new Error(`Invalid ${label} sync payload.`);
-    }
-    const payload = input;
-    for (const table of tables) {
-        if (!Array.isArray(payload.tables?.[table])) {
-            throw new Error(`Invalid ${label} sync payload: missing ${String(table)}.`);
-        }
-    }
-    return payload;
-}
-export function exportTables(db, tables) {
-    const out = {};
-    for (const table of tables) {
-        const rows = dbAll(db, `SELECT * FROM "${String(table).replace(/"/g, '""')}"`);
-        out[table] = rows.filter((row) => !isTempSyncRow(row));
-    }
-    return {
-        version: readPayloadVersion({ version: 0, exportedAt: '', tables: out }),
-        exportedAt: new Date().toISOString(),
-        tables: out,
-    };
-}
-export function importTables(db, tables, payload, opts) {
-    const asRec = payload.tables;
-    const remoteLibraryRows = opts.libraryTables.reduce((n, t) => n + (asRec[t]?.length ?? 0), 0);
-    const localLibraryRows = opts.libraryTables.length === 0
-        ? 1
-        : (dbGet(db, `SELECT ${opts.libraryTables
-            .map((t) => `(SELECT COUNT(*) FROM "${String(t).replace(/"/g, '""')}")`)
-            .join(' + ')} AS n`)?.n ?? 0);
-    if (remoteLibraryRows === 0 && localLibraryRows > 0) {
-        throw new Error('Sync down refused: remote library is empty while local library has data');
-    }
-    try {
-        db.backup(path.join(CONFIG.ROOT, opts.backupName));
-    }
-    catch (err) {
-        log.warn({ err }, 'Pre-sync backup failed, continuing without backup');
-    }
-    const localColumns = new Map();
-    for (const table of tables) {
-        const cols = db.all(`PRAGMA table_info("${String(table)}")`);
-        localColumns.set(String(table), new Set(cols.map((c) => c.name)));
-    }
-    db.serialize(() => {
-        for (const table of tables) {
-            db.run(`DELETE FROM "${String(table).replace(/"/g, '""')}"`);
-        }
-        for (const table of tables) {
-            const known = localColumns.get(String(table));
-            for (const row of asRec[String(table)] || []) {
-                if (isTempSyncRow(row))
-                    continue;
-                const columns = Object.keys(row).filter((c) => known?.has(c));
-                if (columns.length === 0)
-                    continue;
-                const columnSql = columns.map((c) => `"${c.replace(/"/g, '""')}"`).join(', ');
-                const placeholders = columns.map(() => '?').join(', ');
-                const values = columns.map((c) => row[c]);
-                db.run(`INSERT INTO "${String(table).replace(/"/g, '""')}" (${columnSql}) VALUES (${placeholders})`, values);
-            }
-        }
-    });
-}