@serifpersia/dango 3.6.7 → 3.6.9

package/server/dist/app-hono.js

@@ -1,598 +0,0 @@
-import { Hono } from 'hono';
-import { compress } from 'hono/compress';
-import { getConnInfo } from '@hono/node-server/conninfo';
-import path from 'path';
-import fs from 'fs';
-import { XMLParser } from 'fast-xml-parser';
-import { CONFIG } from './config.js';
-import { isAllowedOrigin } from './utils/security.utils.js';
-import { requestContext } from './utils/request-context.js';
-import logger from './logger.js';
-import { LAN_AUTH_PUBLIC_PATHS, buildLanCookie, clearAllLanSessions, clearLanCookie, createLanSession, getTokenFromHeaders, hasAppPassword, isLoopbackIp, revokeLanSession, setAppPassword, validateLanSession, verifyAppPassword, } from './app-auth.js';
-import { importMangaFromMalXmlItems, } from './lib/tracker/manga-sync.service.js';
-import { LibraryRepository } from './repositories/library.repository.js';
-import { performAsmrWriteTransactionAsync, performMangaWriteTransactionAsync, performTvWriteTransactionAsync, performWriteTransactionAsync, KIND_SYNC, setKindManifestVersion, } from './sync.js';
-import { ANIME_SYNC_TABLES, ASMR_SYNC_TABLES, MANGA_SYNC_TABLES, TV_SYNC_TABLES, exportTables, importTables, normalizePayload, readPayloadVersion, } from './sync-payload.js';
-import { getMalImportStatus, prepareMalImport, executeMalImport } from './lib/mal-import.js';
-import { registerMusic } from './hono/music.js';
-import { registerAuth } from './hono/auth.js';
-import { registerTv } from './hono/tv.js';
-import { registerProxy } from './hono/proxy.js';
-import { fetchRequestHandler } from '@trpc/server/adapters/fetch';
-import { appRouter } from './trpc/router.js';
-import { buildTrpcContext } from './trpc/context.js';
-const malMangaXmlParser = new XMLParser({
-    isArray: (name) => name === 'manga',
-    parseTagValue: false,
-    trimValues: true,
-});
-function mangaXmlText(value) {
-    if (Array.isArray(value))
-        return String(value[0] ?? '');
-    return String(value ?? '');
-}
-function mapMalMangaXmlStatus(status) {
-    switch (status) {
-        case 'Plan to Read':
-            return 'Planned';
-        case 'On Hold':
-            return 'On-Hold';
-        case 'Reading':
-        case 'Completed':
-        case 'Dropped':
-            return status;
-        default:
-            return 'Planned';
-    }
-}
-export function getHonoClientIp(c) {
-    try {
-        return getConnInfo(c).remote.address;
-    }
-    catch {
-        return c.req.header('x-dango-client-ip') ?? undefined;
-    }
-}
-const NOT_READY_HEADER = 'x-dango-not-ready';
-function notReady(c, body) {
-    c.header(NOT_READY_HEADER, '1');
-    return typeof body === 'string' ? c.text(body, 503) : c.json(body, 503);
-}
-export async function honoRequestLogger(c, next) {
-    const start = process.hrtime.bigint();
-    const url = new URL(c.req.url);
-    const loggedUrl = `${url.pathname}${url.search}`;
-    await next();
-    const ms = Math.round((Number(process.hrtime.bigint() - start) / 1_000_000) * 10) / 10;
-    const status = c.res.status;
-    const payload = { method: c.req.method, url: loggedUrl, status, ms };
-    if (status >= 500 && !c.res.headers.get(NOT_READY_HEADER)) {
-        logger.warn(payload, 'request failed');
-    }
-    else if (!loggedUrl.startsWith('/api/proxy')) {
-        logger.trace(`${c.req.method} ${loggedUrl} ${status} ${ms}ms`);
-    }
-}
-export async function honoRequestContextMiddleware(c, next) {
-    const store = new Map();
-    const ua = c.req.header('x-animepahe-ua');
-    if (ua)
-        store.set('ua', ua);
-    const cookie = c.req.header('x-animepahe-cookie');
-    if (cookie)
-        store.set('cookie', cookie);
-    const jasmrUa = c.req.header('x-jasmr-ua');
-    if (jasmrUa)
-        store.set('jasmr_ua', jasmrUa);
-    const jasmrCookie = c.req.header('x-jasmr-cookie');
-    if (jasmrCookie)
-        store.set('jasmr_cookie', jasmrCookie);
-    return requestContext.run(store, () => next());
-}
-async function restoreJsonBackup(c, dbs, buffer) {
-    let parsed;
-    try {
-        parsed = JSON.parse(buffer.toString('utf-8'));
-    }
-    catch {
-        return c.json({ error: 'Invalid backup file.' }, 400);
-    }
-    const databases = parsed?.databases;
-    if (!databases || typeof databases !== 'object') {
-        return c.json({ error: 'Invalid backup file: missing databases.' }, 400);
-    }
-    const kindDbs = {
-        anime: dbs.db,
-        manga: dbs.mangaDb,
-        tv: dbs.tvDb,
-        asmr: dbs.asmrDb,
-    };
-    const targets = Object.keys(KIND_SYNC).map((kind) => ({
-        key: kind,
-        db: kindDbs[kind],
-        tables: KIND_SYNC[kind].tables,
-        libraryTables: KIND_SYNC[kind].libraryTables,
-        backupName: KIND_SYNC[kind].backupName,
-        setVersion: (version) => setKindManifestVersion(kind, version),
-    }));
-    const present = targets.filter((t) => databases[t.key] !== undefined);
-    if (present.length === 0) {
-        return c.json({ error: 'Invalid backup file: no databases found.' }, 400);
-    }
-    const sections = new Map();
-    try {
-        for (const target of present) {
-            sections.set(target.key, normalizePayload(databases[target.key], target.tables, `backup ${target.key}`));
-        }
-    }
-    catch (err) {
-        logger.warn({ err }, 'Multi-database restore rejected: invalid payload');
-        return c.json({ error: 'Invalid backup file.' }, 400);
-    }
-    const restored = [];
-    try {
-        for (const target of present) {
-            const section = sections.get(target.key);
-            if (!section)
-                continue;
-            importTables(target.db, target.tables, section, {
-                libraryTables: target.libraryTables,
-                backupName: target.backupName,
-            });
-            await target.setVersion(readPayloadVersion(section));
-            restored.push(target.key);
-        }
-    }
-    catch (err) {
-        logger.error({ err, restored }, 'Multi-database restore failed partway');
-        return c.json({ error: 'Restore failed partway.', restored }, 500);
-    }
-    logger.warn({ restored }, 'Databases restored from backup file by user request');
-    return c.json({ success: true, message: 'Databases restored.', restored });
-}
-function restoreLegacyDatabase(c, dbs, buffer, dbAdmin) {
-    const dbName = CONFIG.IS_DEV ? CONFIG.DB_NAME_DEV : CONFIG.DB_NAME_PROD;
-    const tempPath = path.join(CONFIG.ROOT, 'restore_temp.db');
-    const dbPath = path.join(CONFIG.ROOT, dbName);
-    try {
-        fs.writeFileSync(tempPath, buffer);
-    }
-    catch (err) {
-        logger.error({ err }, 'Failed to stage legacy database restore file');
-        return Promise.resolve(c.json({ error: 'Failed to stage restore file.' }, 500));
-    }
-    const db = dbs.db;
-    return new Promise((resolve) => {
-        db.close((closeErr) => {
-            if (closeErr) {
-                resolve(c.json({ error: 'Failed to close database.' }, 500));
-                return;
-            }
-            try {
-                db.checkpoint();
-            }
-            catch (checkpointErr) {
-                logger.warn({ err: checkpointErr }, 'WAL checkpoint failed');
-            }
-            try {
-                if (fs.existsSync(`${dbPath}-wal`))
-                    fs.unlinkSync(`${dbPath}-wal`);
-                if (fs.existsSync(`${dbPath}-shm`))
-                    fs.unlinkSync(`${dbPath}-shm`);
-            }
-            catch (cleanupErr) {
-                logger.warn({ err: cleanupErr }, 'Failed to clean up WAL files');
-            }
-            fs.rename(tempPath, dbPath, async (renameErr) => {
-                if (renameErr) {
-                    try {
-                        dbAdmin.setDb(await dbAdmin.initializeDatabase(dbPath));
-                    }
-                    catch (e) {
-                        logger.error({ err: e }, 'Failed to reopen DB after rename failure');
-                    }
-                    resolve(c.json({ error: 'Failed to replace database file.' }, 500));
-                    return;
-                }
-                try {
-                    dbAdmin.setDb(await dbAdmin.initializeDatabase(dbPath));
-                    resolve(c.json({ success: true, message: 'Database restored.' }));
-                }
-                catch (e) {
-                    logger.error({ err: e }, 'Failed to initialize restored database');
-                    resolve(c.json({ error: 'Failed to initialize restored database.' }, 500));
-                }
-            });
-        });
-    });
-}
-export function createHonoApp(getState, getGuardState, getDbs, dbAdmin, providerApi, runSync, media) {
-    const app = new Hono();
-    app.use(honoRequestLogger);
-    app.use(honoRequestContextMiddleware);
-    app.get('/api/health', (c) => {
-        const state = getState();
-        if (state.shuttingDown) {
-            return notReady(c, { status: 'shutting-down', ready: false });
-        }
-        if (!state.dbReady) {
-            return notReady(c, { status: 'starting', ready: false });
-        }
-        return c.json({ status: 'ok', ready: true });
-    });
-    app.use(async (c, next) => {
-        const guard = getGuardState();
-        if (guard.shuttingDown) {
-            return notReady(c, 'Server is shutting down...');
-        }
-        if (!guard.dbsReady) {
-            return notReady(c, 'Database initializing...');
-        }
-        if (guard.bootSyncing &&
-            c.req.method !== 'GET' &&
-            c.req.method !== 'HEAD' &&
-            c.req.method !== 'OPTIONS') {
-            return notReady(c, 'Sync in progress...');
-        }
-        await next();
-    });
-    const honoCompress = compress({ threshold: 1024 });
-    app.use(async (c, next) => {
-        if (c.req.header('x-no-compression')) {
-            await next();
-            return;
-        }
-        await honoCompress(c, next);
-    });
-    app.use(async (c, next) => {
-        const origin = c.req.header('origin');
-        if (c.req.method === 'OPTIONS') {
-            if (!origin || !isAllowedOrigin(origin)) {
-                await next();
-                return;
-            }
-            const reqHeaders = c.req.header('access-control-request-headers');
-            return new Response(null, {
-                status: 204,
-                headers: {
-                    'Access-Control-Allow-Origin': origin,
-                    'Access-Control-Allow-Credentials': 'true',
-                    'Access-Control-Allow-Methods': 'GET,HEAD,PUT,PATCH,POST,DELETE',
-                    ...(reqHeaders ? { 'Access-Control-Allow-Headers': reqHeaders } : {}),
-                    Vary: 'Origin',
-                },
-            });
-        }
-        if (!origin || isAllowedOrigin(origin)) {
-            if (origin)
-                c.header('Access-Control-Allow-Origin', origin);
-            c.header('Access-Control-Allow-Credentials', 'true');
-            c.header('Vary', 'Origin');
-        }
-        await next();
-    });
-    app.use(async (c, next) => {
-        const method = c.req.method.toUpperCase();
-        if (!['POST', 'PUT', 'DELETE', 'PATCH'].includes(method)) {
-            await next();
-            return;
-        }
-        const secFetchSite = c.req.header('sec-fetch-site');
-        if (secFetchSite === 'cross-site') {
-            const origin = c.req.header('origin');
-            if (!isAllowedOrigin(origin)) {
-                return c.json({ error: 'Forbidden: cross-site request rejected' }, 403);
-            }
-        }
-        const origin = c.req.header('origin');
-        if (origin && !isAllowedOrigin(origin)) {
-            return c.json({ error: 'Forbidden: cross-origin request rejected' }, 403);
-        }
-        await next();
-    });
-    app.get('/api/auth/app-status', (c) => {
-        const authed = !hasAppPassword() ||
-            validateLanSession(getTokenFromHeaders(c.req.header('authorization'), c.req.header('cookie')));
-        return c.json({ hasPassword: hasAppPassword(), isAuthenticated: authed, port: CONFIG.PORT });
-    });
-    app.post('/api/auth/app-login', async (c) => {
-        const body = (await c.req.json().catch(() => undefined));
-        const password = String(body?.password || '');
-        if (!hasAppPassword()) {
-            return c.json({ success: true });
-        }
-        if (!password) {
-            return c.json({ error: 'Password required' }, 400);
-        }
-        if (!verifyAppPassword(password)) {
-            return c.json({ error: 'Invalid password' }, 401);
-        }
-        const session = createLanSession();
-        c.header('Set-Cookie', buildLanCookie(session.token, session.expiry));
-        return c.json({ success: true });
-    });
-    app.post('/api/auth/app-logout', (c) => {
-        revokeLanSession(getTokenFromHeaders(c.req.header('authorization'), c.req.header('cookie')));
-        c.header('Set-Cookie', clearLanCookie());
-        return c.json({ success: true });
-    });
-    app.post('/api/auth/app-setup', async (c) => {
-        if (!isLoopbackIp(c.req.header('x-dango-client-ip'))) {
-            return c.json({ error: 'Forbidden' }, 403);
-        }
-        const body = (await c.req.json().catch(() => undefined));
-        const password = String(body?.password || '');
-        try {
-            await setAppPassword(password);
-            clearAllLanSessions();
-            return c.json({ success: true, hasPassword: hasAppPassword() });
-        }
-        catch {
-            return c.json({ error: 'Failed to update password' }, 500);
-        }
-    });
-    app.use(async (c, next) => {
-        const path = c.req.path;
-        if (!path.startsWith('/api/')) {
-            await next();
-            return;
-        }
-        if (LAN_AUTH_PUBLIC_PATHS.has(path)) {
-            await next();
-            return;
-        }
-        if (path.startsWith('/api/internal/') && isLoopbackIp(getHonoClientIp(c))) {
-            await next();
-            return;
-        }
-        if (!hasAppPassword()) {
-            await next();
-            return;
-        }
-        if (validateLanSession(getTokenFromHeaders(c.req.header('authorization'), c.req.header('cookie')))) {
-            await next();
-            return;
-        }
-        return c.json({ error: 'LAN_AUTH_REQUIRED' }, 401);
-    });
-    app.all('/api/trpc/*', (c) => fetchRequestHandler({
-        endpoint: '/api/trpc',
-        req: c.req.raw,
-        router: appRouter,
-        createContext: () => buildTrpcContext({
-            ...getDbs(),
-            apiCache: media.getApiCache(),
-            getTvProvider: media.getTvProvider,
-            getMangaProvider: media.getMangaProvider,
-            getJasmr: media.getJasmr,
-            getProviders: media.getProviders,
-            getCatalog: providerApi.getCatalog,
-        }, c.req.header('authorization'), c.req.header('cookie')),
-    }));
-    app.post('/api/import/mal-xml', async (c) => {
-        const dbs = getDbs();
-        const fields = (await c.req.parseBody().catch(() => ({})));
-        const file = fields['xmlfile'];
-        const buffer = file instanceof File ? Buffer.from(await file.arrayBuffer()) : undefined;
-        const prepared = prepareMalImport(buffer, {
-            erase: fields['erase'],
-            useOfflineDb: fields['useOfflineDb'],
-            skipFallback: fields['skipFallback'],
-        });
-        if (!prepared.ok)
-            return c.json(prepared.body, prepared.status);
-        const stream = new TransformStream();
-        const writer = stream.writable.getWriter();
-        const encoder = new TextEncoder();
-        let disconnected = false;
-        c.req.raw.signal.addEventListener('abort', () => {
-            disconnected = true;
-        }, { once: true });
-        const sendEvent = (event, data) => {
-            if (disconnected)
-                return;
-            void writer
-                .write(encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`))
-                .catch(() => { });
-        };
-        void executeMalImport(dbs.db, prepared.import, sendEvent).finally(() => {
-            void writer.close().catch(() => { });
-        });
-        return new Response(stream.readable, {
-            headers: {
-                'Content-Type': 'text/event-stream',
-                'Cache-Control': 'no-cache',
-                Connection: 'keep-alive',
-            },
-        });
-    });
-    app.get('/api/providers', (c) => {
-        c.header('Cache-Control', 'public, max-age=300');
-        return c.json(providerApi.getCatalog());
-    });
-    app.post('/api/providers/refresh', async (c) => {
-        try {
-            return c.json(await providerApi.refresh());
-        }
-        catch (err) {
-            return c.json({ error: err.message || 'refresh failed' }, 500);
-        }
-    });
-    app.get('/api/tracker/anilist/callback', (c) => {
-        return c.html(`<!doctype html>
-<html><head><meta charset="utf-8"><title>AniList — completing login</title></head>
-<body style="font-family:system-ui;padding:24px;background:#0b1426;color:#e5eefc"><p>Completing AniList login…</p>
-<script>
-(function(){
-  var qs = new URLSearchParams(location.search);
-  var state = qs.get('state');
-  var hash = location.hash || '';
-  var hp = new URLSearchParams(hash.slice(1));
-  if (!state) state = hp.get('state');
-  var token = hp.get('access_token');
-  var error = hp.get('error') || qs.get('error');
-  var frontend = location.origin + '/trackers';
-  if (state) {
-    try {
-      var candidate = decodeURIComponent(state);
-      if (candidate.startsWith('/') && !candidate.startsWith('//')) {
-        frontend = location.origin + candidate;
-      } else {
-        var parsed = new URL(candidate, location.origin);
-        if (parsed.origin === location.origin) {
-          frontend = parsed.href;
-        }
-      }
-    } catch(e) {}
-  }
-  if (frontend.indexOf('/api/tracker/anilist/callback') !== -1) {
-    frontend = location.origin + '/trackers';
-  }
-  if (error) {
-    location.replace(frontend + (frontend.indexOf('?') !== -1 ? '&' : '?') + 'anilist=error&reason=' + encodeURIComponent(error));
-    return;
-  }
-  if (token) {
-    location.replace(frontend + hash);
-    return;
-  }
-  var code = qs.get('code');
-  if (code) {
-    location.replace(frontend + (frontend.indexOf('?') !== -1 ? '&' : '?') + 'anilist=error&reason=code_flow_removed');
-    return;
-  }
-  location.replace(frontend + (frontend.indexOf('?') !== -1 ? '&' : '?') + 'anilist=error&reason=no_token');
-})();
-</script></body></html>`);
-    });
-    app.post('/api/import/mal-xml-manga', async (c) => {
-        const fields = (await c.req.parseBody().catch(() => ({})));
-        const file = fields['xmlfile'];
-        if (!(file instanceof File))
-            return c.json({ error: 'No file' }, 400);
-        const eraseRaw = fields['erase'];
-        const erase = eraseRaw === true || eraseRaw === 'true' || eraseRaw === '1';
-        try {
-            const dbs = getDbs();
-            if (!dbs.mangaDb || dbs.mangaDb.isClosedCheck()) {
-                return notReady(c, { error: 'Manga database is not ready' });
-            }
-            let result;
-            try {
-                result = malMangaXmlParser.parse(Buffer.from(await file.arrayBuffer()).toString());
-            }
-            catch {
-                return c.json({ error: 'Invalid XML' }, 400);
-            }
-            const mangaList = result?.myanimelist?.manga || [];
-            if (mangaList.length === 0) {
-                return c.json({ error: 'No manga found in XML' }, 400);
-            }
-            const items = mangaList.map((item) => ({
-                malId: parseInt(mangaXmlText(item.series_mangadb_id), 10) || 0,
-                title: mangaXmlText(item.series_title),
-                status: mapMalMangaXmlStatus(mangaXmlText(item.my_status)),
-                chapters: Math.max(parseInt(mangaXmlText(item.my_read_chapters), 10) || 0, 0),
-            }));
-            const { imported, skipped } = await importMangaFromMalXmlItems(dbs.db, dbs.mangaDb, items, erase);
-            return c.json({ success: true, imported, skipped });
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : 'Import failed';
-            return c.json({ error: message }, 500);
-        }
-    });
-    app.get('/api/backup-db', (c) => {
-        try {
-            const dbs = getDbs();
-            const payload = {
-                version: 1,
-                exportedAt: new Date().toISOString(),
-                databases: {
-                    anime: exportTables(dbs.db, ANIME_SYNC_TABLES),
-                    manga: exportTables(dbs.mangaDb, MANGA_SYNC_TABLES),
-                    tv: exportTables(dbs.tvDb, TV_SYNC_TABLES),
-                    asmr: exportTables(dbs.asmrDb, ASMR_SYNC_TABLES),
-                },
-            };
-            c.header('Content-Disposition', 'attachment; filename="dango-backup.json"');
-            return c.json(payload);
-        }
-        catch (err) {
-            logger.error({ err }, 'Multi-database backup failed');
-            return c.json({ error: 'Backup failed' }, 500);
-        }
-    });
-    app.post('/api/database/clear', async (c) => {
-        const body = (await c.req.json().catch(() => undefined));
-        if (body?.confirm !== true) {
-            return c.json({ error: 'Confirmation required' }, 400);
-        }
-        if (getMalImportStatus().running) {
-            return c.json({ error: 'An import is in progress' }, 409);
-        }
-        try {
-            const dbs = getDbs();
-            const before = await LibraryRepository.countAll(dbs.db);
-            const beforeManga = await LibraryRepository.countManga(dbs.mangaDb);
-            const beforeTv = await LibraryRepository.countTv(dbs.tvDb);
-            const beforeAsmr = await LibraryRepository.countAsmr(dbs.asmrDb);
-            await performWriteTransactionAsync(dbs.db, async (tx) => {
-                await LibraryRepository.clearAll(tx);
-            });
-            await performMangaWriteTransactionAsync(dbs.mangaDb, async (tx) => {
-                await LibraryRepository.clearManga(tx);
-            });
-            await performTvWriteTransactionAsync(dbs.tvDb, async (tx) => {
-                await LibraryRepository.clearTv(tx);
-            });
-            await performAsmrWriteTransactionAsync(dbs.asmrDb, async (tx) => {
-                await LibraryRepository.clearAsmr(tx);
-            });
-            logger.warn({ before, beforeManga, beforeTv, beforeAsmr }, 'Library database cleared by user request');
-            return c.json({
-                success: true,
-                deleted: before,
-                deletedManga: beforeManga,
-                deletedTv: beforeTv,
-                deletedAsmr: beforeAsmr,
-            });
-        }
-        catch {
-            return c.json({ error: 'DB error' }, 500);
-        }
-    });
-    app.post('/api/restore-db', async (c) => {
-        const dbs = getDbs();
-        let buffer;
-        let originalName = '';
-        try {
-            const body = await c.req.parseBody();
-            const file = body['dbfile'];
-            if (file instanceof File) {
-                buffer = Buffer.from(await file.arrayBuffer());
-                originalName = file.name || '';
-            }
-        }
-        catch {
-            return c.json({ error: 'No file uploaded.' }, 400);
-        }
-        if (!buffer)
-            return c.json({ error: 'No file uploaded.' }, 400);
-        const head = buffer.slice(0, 16).toString('utf-8').trimStart();
-        if (originalName.endsWith('.json') || head.startsWith('{')) {
-            return restoreJsonBackup(c, dbs, buffer);
-        }
-        return restoreLegacyDatabase(c, dbs, buffer, dbAdmin);
-    });
-    registerMusic(app);
-    registerAuth(app, getDbs, runSync);
-    registerTv(app, media.getTvProvider);
-    registerProxy(app, media.getProxyRules);
-    app.onError((err, c) => {
-        logger.error({ err, url: c.req.path, method: c.req.method }, 'Unhandled error');
-        const status = err.status || 500;
-        return c.json({ error: err.message || 'Internal Server Error', status }, status);
-    });
-    return app;
-}

package/server/dist/db/drizzle.js

@@ -1,16 +0,0 @@
-import { drizzle } from 'drizzle-orm/node-sqlite';
-export function createDrizzle(db) {
-    return drizzle({ client: db.getClient() });
-}
-const cache = new WeakMap();
-export function getDrizzle(db) {
-    let d = cache.get(db);
-    if (!d) {
-        d = createDrizzle(db);
-        cache.set(db, d);
-    }
-    return d;
-}
-export async function runTx(db, fn) {
-    await db.transact(fn);
-}

package/server/dist/db/schema-anime.js

@@ -1,61 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { integer, primaryKey, real, sqliteTable, text } from 'drizzle-orm/sqlite-core';
-export const watchedEpisodes = sqliteTable('watched_episodes', {
-    showId: text('showId').notNull(),
-    episodeNumber: text('episodeNumber').notNull(),
-    watchedAt: text('watchedAt'),
-    currentTime: real('currentTime'),
-    duration: real('duration'),
-}, (t) => [primaryKey({ columns: [t.showId, t.episodeNumber] })]);
-export const watchlist = sqliteTable('watchlist', {
-    id: text('id').notNull(),
-    name: text('name'),
-    thumbnail: text('thumbnail'),
-    status: text('status'),
-    nativeName: text('nativeName'),
-    englishName: text('englishName'),
-    type: text('type'),
-}, (t) => [primaryKey({ columns: [t.id] })]);
-export const showsMeta = sqliteTable('shows_meta', {
-    id: text('id').notNull(),
-    name: text('name'),
-    thumbnail: text('thumbnail'),
-    nativeName: text('nativeName'),
-    englishName: text('englishName'),
-    episodeCount: integer('episodeCount'),
-    status: text('status'),
-    genres: text('genres'),
-    popularityScore: integer('popularityScore'),
-    type: text('type'),
-    anilistId: integer('anilistId'),
-    isAdult: integer('isAdult'),
-    episodeDuration: integer('episodeDuration'),
-}, (t) => [primaryKey({ columns: [t.id] })]);
-export const settings = sqliteTable('settings', {
-    key: text('key').notNull(),
-    value: text('value'),
-}, (t) => [primaryKey({ columns: [t.key] })]);
-export const queue = sqliteTable('queue', {
-    id: integer('id'),
-    showId: text('showId').notNull(),
-    episodeNumber: text('episodeNumber').notNull(),
-    queueOrder: integer('queue_order').notNull(),
-});
-export const discoveredNotifications = sqliteTable('discovered_notifications', {
-    showId: text('showId').notNull(),
-    episodeNumber: text('episodeNumber').notNull(),
-    discoveredAt: text('discoveredAt').default(sql `CURRENT_TIMESTAMP`),
-}, (t) => [primaryKey({ columns: [t.showId, t.episodeNumber] })]);
-export const dismissedNotifications = sqliteTable('dismissed_notifications', {
-    showId: text('showId').notNull(),
-    episodeNumber: text('episodeNumber').notNull(),
-    dismissedAt: text('dismissedAt').default(sql `CURRENT_TIMESTAMP`),
-}, (t) => [primaryKey({ columns: [t.showId, t.episodeNumber] })]);
-export const tempShowIds = sqliteTable('temp_show_ids', {
-    id: text('id').notNull(),
-    provider: text('provider').notNull(),
-    nativeId: text('nativeId').notNull(),
-    title: text('title').notNull(),
-    thumbnail: text('thumbnail'),
-    createdAt: integer('createdAt').notNull(),
-}, (t) => [primaryKey({ columns: [t.id] })]);

package/server/dist/db/schema-asmr.js

@@ -1,13 +0,0 @@
-import { integer, primaryKey, real, sqliteTable, text } from 'drizzle-orm/sqlite-core';
-export const asmrProgress = sqliteTable('asmr_progress', {
-    workId: text('workId').notNull(),
-    trackIndex: integer('trackIndex').notNull(),
-    trackLabel: text('trackLabel'),
-    currentTime: real('currentTime'),
-    duration: real('duration'),
-    updatedAt: integer('updatedAt'),
-    title: text('title'),
-    thumbnail: text('thumbnail'),
-    rjCode: text('rjCode'),
-    isAdult: integer('isAdult'),
-}, (t) => [primaryKey({ columns: [t.workId, t.trackIndex] })]);