@serifpersia/dango 3.4.1 → 3.4.3

package/server/dist/db.js

@@ -27,8 +27,9 @@ export class DatabaseWrapper {
             throw e;
         }
     }
-    scheduleSave() { }
-    async saveNow() { }
+    getClient() {
+        return this.db;
+    }
     configure(option, value) {
         if (option === 'busyTimeout') {
             this.db.exec(`PRAGMA busy_timeout = ${value}`);

package/server/dist/hono/tv.js

@@ -1,3 +1,4 @@
+import logger from '../logger.js';
 import { parseJsonBody } from '../utils/http.utils.js';
 import { getTmdbKey, TMDB_BASE, TMDB_IMAGE } from '../lib/tmdb.js';
 import { URL } from 'url';
@@ -161,7 +162,8 @@ export function registerTv(app, getApiCache, getTvProvider) {
             const chunks = [];
             const reader = fetchResp.body?.getReader();
             if (!reader) {
-                return c.text('No response body', 500);
+                logger.warn({ host: safeCheck.url?.hostname }, 'tv stream-proxy: upstream sent no body');
+                return c.text('Upstream sent no body', 502);
             }
             try {
                 while (true) {
@@ -181,14 +183,16 @@ export function registerTv(app, getApiCache, getTvProvider) {
                 }
                 return new Response(body, { status, headers: outHeaders });
             }
-            catch {
-                return c.text('Proxy error', 500);
+            catch (err) {
+                logger.warn({ err, host: safeCheck.url?.hostname }, 'tv stream-proxy: upstream body stream failed');
+                return c.text('Upstream stream failed', 502);
             }
         }
-        catch {
+        catch (err) {
             if (abort.signal.aborted)
                 return new Response(null, { status: 499 });
-            return c.text('Proxy error', 500);
+            logger.warn({ err, host: safeCheck.url?.hostname }, 'tv stream-proxy: upstream fetch failed');
+            return c.text('Upstream fetch failed', 502);
         }
         finally {
             clearTimeout(timeout);

package/server/dist/hono/watchlist.js

@@ -1,14 +1,12 @@
 import logger from '../logger.js';
-import { performWriteTransactionAsync } from '../sync.js';
 import { WatchlistRepository } from '../repositories/watchlist.repository.js';
 import { WatchedEpisodesRepository, } from '../repositories/watched-episodes.repository.js';
 import { ShowsMetaRepository } from '../repositories/shows-meta.repository.js';
 import { NotificationsRepository } from '../repositories/notifications.repository.js';
 import { SettingsRepository } from '../repositories/settings.repository.js';
-import { discordRPCService } from '../discord-rpc.js';
-import { dbAll, dbGet } from '../utils/db-utils.js';
+import { dbAll } from '../utils/db-utils.js';
+import { AppCache } from '../utils/cache.utils.js';
 import { searchAnilist, getAiredEpisodesForShows, getAnilistEpisodes, getShowMetaById, isAnilistRateLimited, batchGetShowStatuses, } from '../lib/anilist.js';
-import { getMigratedId } from '../lib/migration.js';
 import { offlineDb } from '../lib/offline-db.js';
 import { parseJsonBody } from '../utils/http.utils.js';
 import { pickBestMatch } from '../providers/title-matching.js';
@@ -147,8 +145,6 @@ export function startWatchlistDiscovery(getDb) {
                         persisted++;
                     }
                 }
-                if (persisted > 0)
-                    db.scheduleSave();
             }
             if (finishedShowIds.size > 0) {
                 const monthStart = new Date(now);
@@ -192,8 +188,6 @@ export function startWatchlistDiscovery(getDb) {
                             inserted = true;
                         }
                     }
-                    if (inserted)
-                        db.scheduleSave();
                 }
             }
             const episodesByShow = new Map();
@@ -229,8 +223,6 @@ export function startWatchlistDiscovery(getDb) {
                         inserted = true;
                     }
                 }
-                if (inserted)
-                    db.scheduleSave();
             }
             await NotificationsRepository.cleanupWatchedNotifications(db);
         }
@@ -474,7 +466,6 @@ async function backfillMissingPosters(db, rows) {
             // ignore
         }
     }));
-    db.scheduleSave();
     await sweepOfflinePosters(db);
 }
 async function sweepOfflinePosters(db) {
@@ -498,7 +489,6 @@ async function sweepOfflinePosters(db) {
         if (poster)
             await applyPoster(db, id, poster);
     }
-    db.scheduleSave();
 }
 function resolveOfflinePoster(id) {
     if (/^\d+$/.test(id)) {
@@ -563,15 +553,15 @@ async function resolveAvailableEpisodes(db, showId) {
         : [];
     return episodes;
 }
-const dlsitePosterCache = new Map();
-const mangadexCoverCache = new Map();
+const dlsitePosterCache = new AppCache({ ttlSeconds: 3600, maxKeys: 2000 });
+const mangadexCoverCache = new AppCache({ ttlSeconds: 3600, maxKeys: 2000 });
 export async function getMangadexCover(title) {
     const key = title.trim().toLowerCase();
     if (!key)
         return null;
     const cached = mangadexCoverCache.get(key);
-    if (cached && Date.now() - cached.ts < 3600_000)
-        return cached.url;
+    if (cached !== undefined)
+        return cached;
     try {
         const params = new URLSearchParams({
             title: title.trim(),
@@ -607,7 +597,7 @@ export async function getMangadexCover(title) {
         }
         const match = pickBestMatch(candidates, [title]);
         const url = match ? match.item.cover : null;
-        mangadexCoverCache.set(key, { url, ts: Date.now() });
+        mangadexCoverCache.set(key, url);
         return url;
     }
     catch {
@@ -619,8 +609,8 @@ export async function getDlsitePoster(rjCode) {
     if (!/^RJ\d{5,}$/.test(key))
         return null;
     const cached = dlsitePosterCache.get(key);
-    if (cached && Date.now() - cached.ts < 3600_000)
-        return cached.url;
+    if (cached !== undefined)
+        return cached;
     try {
         const res = await fetch(`https://www.dlsite.com/maniax/product/info/ajax?product_id=${key}`, {
             headers: { 'User-Agent': 'Mozilla/5.0', Accept: 'application/json' },
@@ -636,98 +626,10 @@ export async function getDlsitePoster(rjCode) {
         if (!img)
             return null;
         const url = img.startsWith('//') ? `https:${img}` : img;
-        dlsitePosterCache.set(key, { url, ts: Date.now() });
+        dlsitePosterCache.set(key, url);
         return url;
     }
     catch {
         return null;
     }
 }
-export function registerWatchlist(app, getDbs) {
-    const db = () => getDbs().db;
-    app.post('/api/update-progress', async (c) => {
-        const { showId: showIdRaw, episodeNumber, currentTime, duration, showName, showThumbnail, nativeName, englishName, genres, popularityScore, type, status, episodeCount, isPlaying, sessionId, isAdult, } = (await c.req.json());
-        const showId = await getMigratedId(db(), showIdRaw);
-        const titlePreferenceRow = await SettingsRepository.getByKey(db(), 'titlePreference');
-        const titlePreference = titlePreferenceRow ? titlePreferenceRow.value : 'englishName';
-        let displayName = showName;
-        if (titlePreference === 'englishName' && englishName) {
-            displayName = englishName;
-        }
-        else if (titlePreference === 'nativeName' && nativeName) {
-            displayName = nativeName;
-        }
-        discordRPCService.updatePresence({
-            title: displayName,
-            episode: String(episodeNumber),
-            totalEpisodes: episodeCount ? String(episodeCount) : undefined,
-            currentTime: currentTime || 0,
-            duration: duration || 0,
-            thumbnail: showThumbnail || '',
-            isPlaying: isPlaying !== false,
-            sessionId: sessionId,
-            isAdult: isAdult,
-        });
-        const genresStr = Array.isArray(genres) ? JSON.stringify(genres) : genres;
-        const anilistId = /^\d+$/.test(showId)
-            ? (dbGet(db(), 'SELECT anilistId FROM shows_meta WHERE id = ? AND anilistId IS NOT NULL', [showId])?.anilistId ?? parseInt(showId))
-            : undefined;
-        const metaCandidate = {
-            name: showName,
-            thumbnail: showThumbnail,
-            nativeName: nativeName,
-            englishName: englishName,
-            genres: genresStr,
-            popularityScore: popularityScore,
-            status: status,
-            episodeCount: episodeCount,
-            type: type,
-            anilistId,
-            isAdult: typeof isAdult === 'boolean' ? (isAdult ? 1 : 0) : null,
-            episodeDuration: duration > 0 ? Math.round(duration / 60) : undefined,
-        };
-        const metaChanged = await showsMetaChanged(db(), showId, metaCandidate);
-        if (metaChanged) {
-            await performWriteTransactionAsync(db(), async (tx) => {
-                await ShowsMetaRepository.upsert(tx, {
-                    id: showId,
-                    ...metaCandidate,
-                });
-            });
-        }
-        await performWriteTransactionAsync(db(), async (tx) => {
-            await WatchedEpisodesRepository.upsert(tx, {
-                showId,
-                episodeNumber: episodeNumber,
-                currentTime: currentTime,
-                duration: duration,
-            });
-            await NotificationsRepository.deleteSpecificDismissed(tx, showId, episodeNumber);
-            await NotificationsRepository.deleteDiscovered(tx, showId, episodeNumber);
-        });
-        db().scheduleSave();
-        return c.json({ success: true });
-    });
-    app.post('/api/discord/clear', async (c) => {
-        const { sessionId } = (await c.req.json());
-        if (!discordRPCService.isServiceEnabled) {
-            return c.json({ success: true });
-        }
-        discordRPCService.clearPresence(sessionId);
-        return c.json({ success: true });
-    });
-    app.post('/api/discord/heartbeat', async (c) => {
-        const body = (await c.req.json().catch(() => undefined));
-        const { sessionId, bye } = body ?? {};
-        if (typeof sessionId !== 'string' || !discordRPCService.isServiceEnabled) {
-            return c.json({ success: true });
-        }
-        if (bye) {
-            discordRPCService.removeHeartbeat(sessionId);
-        }
-        else {
-            discordRPCService.heartbeat(sessionId);
-        }
-        return c.json({ success: true });
-    });
-}

package/server/dist/lib/migration.js

@@ -62,7 +62,6 @@ async function consolidateFromNumeric(db, numericId) {
                     canonicalId,
                 ]);
             });
-            db.scheduleSave();
             return canonicalId;
         }
         if (await WatchlistRepository.exists(db, canonicalId)) {
@@ -72,7 +71,6 @@ async function consolidateFromNumeric(db, numericId) {
                     numericId,
                     canonicalId,
                 ]);
-                db.scheduleSave();
                 logger.info({ aliasId: numericId, canonicalId }, 'Mapped numeric alias to canonical ID');
             }
             return canonicalId;
@@ -133,7 +131,6 @@ async function consolidateFromNumeric(db, numericId) {
             numericId,
         ]);
     });
-    db.scheduleSave();
     return numericId;
 }
 async function migrateId(db, legacyId) {
@@ -190,7 +187,6 @@ async function migrateId(db, legacyId) {
                     legacyId,
                 ]);
             });
-            db.scheduleSave();
             logger.info({ legacyId, previousId: mapping.numericId, newId: canonicalId }, 'Canonicalized migrated show ID');
             return canonicalId;
         }
@@ -278,7 +274,6 @@ async function migrateId(db, legacyId) {
             ]);
             tx.run('DELETE FROM discovered_notifications WHERE showId = ?', [legacyId]);
         });
-        db.scheduleSave();
         logger.info({ legacyId, newId, showName }, 'Successfully migrated legacy show ID to numeric ID');
         return newId;
     }

package/server/dist/providers/remote-loader.js

@@ -60,7 +60,7 @@ async function readModuleBytes(entryUrl) {
     return await fs.promises.readFile(filePath);
 }
 function resolveEntryUrl(entry, registryUrl) {
-    const e = entry.trim();
+    const e = (entry ?? '').trim();
     if (isHttp(e) || e.startsWith('file://'))
         return e;
     if (isHttp(registryUrl))
@@ -176,6 +176,26 @@ function createCtx(cache) {
             buildQueryVariants,
             pickBestMatch,
         },
+        resolveBestShowId: async (title, romaji, searchFn) => {
+            const targets = [title, romaji].filter((t) => typeof t === 'string' && t.trim().length > 0);
+            if (targets.length === 0)
+                return null;
+            for (const variant of buildQueryVariants(title, romaji)) {
+                let results;
+                try {
+                    results = await searchFn(variant);
+                }
+                catch {
+                    continue;
+                }
+                if (!results || results.length === 0)
+                    continue;
+                const match = pickBestMatch(results.filter((r) => r && typeof r.id === 'string' && r.id.length > 0), targets);
+                if (match)
+                    return match.item.id;
+            }
+            return null;
+        },
         anilist: {
             request: (query, vars) => anilistRequest(query, vars),
             parseMalId,
@@ -277,7 +297,26 @@ function isValidTvProvider(p) {
     return (typeof o.name === 'string' &&
         (typeof o.getSources === 'function' || typeof o.getEmbedUrl === 'function'));
 }
+function makeEmbedProvider(id, base) {
+    const root = base.trim().replace(/\/+$/, '');
+    return {
+        name: id,
+        getEmbedUrl: async (media) => {
+            const tmdbId = Number(media.tmdbId);
+            if (!tmdbId)
+                return null;
+            if (media.type === 'movie')
+                return `${root}/movie/${tmdbId}`;
+            return `${root}/tv/${tmdbId}/${media.season || 1}/${media.episode || 1}`;
+        },
+    };
+}
 async function loadEntry(item, registryUrl, cacheDir, ctx, allowUnsigned) {
+    if (item.embedBase) {
+        const provider = makeEmbedProvider(item.id, item.embedBase);
+        instanceCache.set(`${item.kind ?? 'anime'}:${item.id}-${item.version}-embed`, { provider });
+        return { provider };
+    }
     const entryUrl = resolveEntryUrl(item.entry, registryUrl);
     await fs.promises.mkdir(cacheDir, { recursive: true });
     const fileName = `${item.id}-${item.version}.mjs`;

package/server/dist/providers/remote-types.js

@@ -39,7 +39,13 @@ function parseEntry(raw, index) {
     if (typeof version !== 'string' || !version.trim()) {
         throw new Error(`registry.providers[${index}].version must be a non-empty string`);
     }
-    if (typeof entry !== 'string' || !entry.trim()) {
+    const embedBase = p.embedBase;
+    if (embedBase !== undefined) {
+        if (typeof embedBase !== 'string' || !/^https:\/\/[^/]+/i.test(embedBase.trim())) {
+            throw new Error(`registry.providers[${index}].embedBase must be an https URL`);
+        }
+    }
+    if ((typeof entry !== 'string' || !entry.trim()) && embedBase === undefined) {
         throw new Error(`registry.providers[${index}].entry must be a non-empty string`);
     }
     if (p.sha256 !== undefined && (typeof p.sha256 !== 'string' || !SHA_RE.test(p.sha256.trim()))) {
@@ -78,7 +84,8 @@ function parseEntry(raw, index) {
         id: id.trim(),
         label: label.trim(),
         version: version.trim(),
-        entry: entry.trim(),
+        entry: typeof entry === 'string' ? entry.trim() : undefined,
+        embedBase: typeof embedBase === 'string' ? embedBase.trim().replace(/\/+$/, '') : undefined,
         sha256: typeof p.sha256 === 'string' ? p.sha256.trim().toLowerCase() : undefined,
         minDango: typeof p.minDango === 'string' ? p.minDango : undefined,
         mature: typeof p.mature === 'boolean' ? p.mature : false,

package/server/dist/server.js

@@ -10,9 +10,8 @@ import { serveStatic } from '@hono/node-server/serve-static';
 import { getConnInfo } from '@hono/node-server/conninfo';
 import logger from './logger.js';
 import { notifyServerExit } from './lib/ipc.js';
-import { githubSyncService } from './github-sync.js';
 import { CONFIG } from './config.js';
-import { initializeDatabase, initializeMangaDatabase, initializeTvDatabase, initializeAsmrDatabase, syncDownOnBoot, syncUp, mangaSyncDownOnBoot, mangaSyncUp, tvSyncDownOnBoot, tvSyncUp, asmrSyncDownOnBoot, asmrSyncUp, initSyncProvider, waitForSync, getActiveProvider, } from './sync.js';
+import { initializeDatabase, initializeMangaDatabase, initializeTvDatabase, initializeAsmrDatabase, runFullSyncSequence, syncUp, waitForSync, KIND_SYNC, } from './sync.js';
 import { loadRemoteProviders } from './providers/remote-loader.js';
 import { discordRPCService } from './discord-rpc.js';
 import { discordGatewayService } from './discord-gateway.js';
@@ -102,77 +101,8 @@ let asmrDb;
 let isShuttingDown = false;
 let bootSyncing = true;
 async function runSyncSequence(database, mangaDatabase, preferredProvider) {
-    const dbName = CONFIG.IS_DEV ? CONFIG.DB_NAME_DEV : CONFIG.DB_NAME_PROD;
-    const dbPath = path.join(CONFIG.ROOT, dbName);
     const remoteFolder = CONFIG.IS_DEV ? CONFIG.REMOTE_FOLDER_DEV : CONFIG.REMOTE_FOLDER_PROD;
-    await initSyncProvider(preferredProvider);
-    if (getActiveProvider() === 'github' && githubSyncService.isAuthenticated()) {
-        try {
-            await githubSyncService.migrateFromAniWebSync();
-        }
-        catch (err) {
-            logger.error({ err }, 'GitHub sync migration from ani-web failed');
-        }
-    }
-    const didDownload = await syncDownOnBoot(database, dbPath, remoteFolder, () => {
-        return new Promise((resolve) => {
-            if (database && !database.isClosedCheck()) {
-                database.checkpoint();
-                database.close(() => resolve());
-            }
-            else {
-                resolve();
-            }
-        });
-    });
-    let currentDb = database;
-    if (didDownload) {
-        db = await initializeDatabase(dbPath);
-        currentDb = db;
-        logger.info('Database re-initialized after sync.');
-    }
-    try {
-        await syncUp(currentDb, dbPath, remoteFolder);
-    }
-    catch (err) {
-        logger.error({ err }, 'Sync up on boot failed');
-    }
-    try {
-        await mangaSyncDownOnBoot(mangaDatabase, remoteFolder);
-    }
-    catch (err) {
-        logger.error({ err }, 'Manga sync down on boot failed');
-    }
-    try {
-        await mangaSyncUp(mangaDatabase, remoteFolder);
-    }
-    catch (err) {
-        logger.error({ err }, 'Manga sync up on boot failed');
-    }
-    try {
-        await tvSyncDownOnBoot(tvDb, remoteFolder);
-    }
-    catch (err) {
-        logger.error({ err }, 'TV sync down on boot failed');
-    }
-    try {
-        await tvSyncUp(tvDb, remoteFolder);
-    }
-    catch (err) {
-        logger.error({ err }, 'TV sync up on boot failed');
-    }
-    try {
-        await asmrSyncDownOnBoot(asmrDb, remoteFolder);
-    }
-    catch (err) {
-        logger.error({ err }, 'ASMR sync down on boot failed');
-    }
-    try {
-        await asmrSyncUp(asmrDb, remoteFolder);
-    }
-    catch (err) {
-        logger.error({ err }, 'ASMR sync up on boot failed');
-    }
+    await runFullSyncSequence({ db: database, mangaDb: mangaDatabase, tvDb, asmrDb }, { remoteFolder, preferredProvider });
 }
 startWatchlistDiscovery(() => db);
 if (!CONFIG.IS_DEV) {
@@ -228,42 +158,28 @@ async function main() {
             refreshRemoteProviders().catch((err) => logger.error({ err }, 'periodic providers refresh failed'));
         }, CONFIG.PROVIDER_REPO_REFRESH_MS).unref();
     }
-    if (!fs.existsSync(CONFIG.LOCAL_MANIFEST_PATH)) {
-        fs.writeFileSync(CONFIG.LOCAL_MANIFEST_PATH, JSON.stringify({ version: 0 }));
-    }
-    if (!fs.existsSync(CONFIG.MANGA_LOCAL_MANIFEST_PATH)) {
-        fs.writeFileSync(CONFIG.MANGA_LOCAL_MANIFEST_PATH, JSON.stringify({ version: 0 }));
-    }
-    if (!fs.existsSync(CONFIG.TV_LOCAL_MANIFEST_PATH)) {
-        fs.writeFileSync(CONFIG.TV_LOCAL_MANIFEST_PATH, JSON.stringify({ version: 0 }));
-    }
-    if (!fs.existsSync(CONFIG.ASMR_LOCAL_MANIFEST_PATH)) {
-        fs.writeFileSync(CONFIG.ASMR_LOCAL_MANIFEST_PATH, JSON.stringify({ version: 0 }));
-    }
-    let hasUnsyncedChanges = false;
-    let hasMangaUnsyncedChanges = false;
-    let hasTvUnsyncedChanges = false;
-    let hasAsmrUnsyncedChanges = false;
-    const watcher = fs.watch(CONFIG.LOCAL_MANIFEST_PATH, (eventType) => {
-        if (eventType === 'change' || eventType === 'rename') {
-            hasUnsyncedChanges = true;
-        }
+    const kindDbs = () => ({
+        anime: db,
+        manga: mangaDb,
+        tv: tvDb,
+        asmr: asmrDb,
     });
-    const mangaWatcher = fs.watch(CONFIG.MANGA_LOCAL_MANIFEST_PATH, (eventType) => {
-        if (eventType === 'change' || eventType === 'rename') {
-            hasMangaUnsyncedChanges = true;
+    for (const kind of Object.keys(KIND_SYNC)) {
+        if (!fs.existsSync(KIND_SYNC[kind].manifestPath)) {
+            fs.writeFileSync(KIND_SYNC[kind].manifestPath, JSON.stringify({ version: 0 }));
         }
-    });
-    const tvWatcher = fs.watch(CONFIG.TV_LOCAL_MANIFEST_PATH, (eventType) => {
-        if (eventType === 'change' || eventType === 'rename') {
-            hasTvUnsyncedChanges = true;
-        }
-    });
-    const asmrWatcher = fs.watch(CONFIG.ASMR_LOCAL_MANIFEST_PATH, (eventType) => {
+    }
+    const unsynced = {
+        anime: false,
+        manga: false,
+        tv: false,
+        asmr: false,
+    };
+    const watchers = Object.keys(KIND_SYNC).map((kind) => fs.watch(KIND_SYNC[kind].manifestPath, (eventType) => {
         if (eventType === 'change' || eventType === 'rename') {
-            hasAsmrUnsyncedChanges = true;
+            unsynced[kind] = true;
         }
-    });
+    }));
     const server = serve({ fetch: app.fetch, port: CONFIG.PORT }, () => {
         logger.info(`Server running on http://localhost:${CONFIG.PORT}`);
     });
@@ -273,49 +189,24 @@ async function main() {
         bootSyncing = false;
     });
     refreshRemoteProviders().catch((err) => logger.error({ err }, 'background providers refresh failed'));
+    const kindDbLabel = {
+        anime: 'database',
+        manga: 'manga database',
+        tv: 'TV database',
+        asmr: 'ASMR database',
+    };
     const syncInterval = setInterval(async () => {
-        if (hasUnsyncedChanges) {
-            logger.info('Uploading accumulated database changes...');
-            hasUnsyncedChanges = false;
-            try {
-                await syncUp(db, dbPath, remoteFolder);
-            }
-            catch (err) {
-                logger.error({ err }, 'Failed to upload database changes');
-                hasUnsyncedChanges = true;
-            }
-        }
-        if (hasMangaUnsyncedChanges) {
-            logger.info('Uploading accumulated manga database changes...');
-            hasMangaUnsyncedChanges = false;
-            try {
-                await mangaSyncUp(mangaDb, remoteFolder);
-            }
-            catch (err) {
-                logger.error({ err }, 'Failed to upload manga database changes');
-                hasMangaUnsyncedChanges = true;
-            }
-        }
-        if (hasTvUnsyncedChanges) {
-            logger.info('Uploading accumulated TV database changes...');
-            hasTvUnsyncedChanges = false;
+        for (const kind of Object.keys(KIND_SYNC)) {
+            if (!unsynced[kind])
+                continue;
+            logger.info(`Uploading accumulated ${kindDbLabel[kind]} changes...`);
+            unsynced[kind] = false;
             try {
-                await tvSyncUp(tvDb, remoteFolder);
+                await syncUp(kindDbs()[kind], kind, remoteFolder);
             }
             catch (err) {
-                logger.error({ err }, 'Failed to upload TV database changes');
-                hasTvUnsyncedChanges = true;
-            }
-        }
-        if (hasAsmrUnsyncedChanges) {
-            logger.info('Uploading accumulated ASMR database changes...');
-            hasAsmrUnsyncedChanges = false;
-            try {
-                await asmrSyncUp(asmrDb, remoteFolder);
-            }
-            catch (err) {
-                logger.error({ err }, 'Failed to upload ASMR database changes');
-                hasAsmrUnsyncedChanges = true;
+                logger.error({ err }, `Failed to upload ${kindDbLabel[kind]} changes`);
+                unsynced[kind] = true;
             }
         }
     }, 300000);
@@ -337,51 +228,28 @@ async function main() {
         clearInterval(offlineDbInterval);
         discordRPCService.disconnect();
         discordGatewayService.shutdown();
-        await watcher.close();
-        await mangaWatcher.close();
-        await tvWatcher.close();
-        await asmrWatcher.close();
+        for (const watcher of watchers) {
+            await watcher.close();
+        }
         if (server) {
             await new Promise((resolve) => server.close(() => resolve()));
         }
-        if (hasUnsyncedChanges) {
-            logger.info('Sync on shutdown: uploading final database changes...');
-            hasUnsyncedChanges = false;
-            try {
-                await syncUp(db, dbPath, remoteFolder);
-            }
-            catch (e) {
-                logger.error({ err: e }, 'Final sync on shutdown failed');
-            }
-        }
-        if (hasMangaUnsyncedChanges) {
-            logger.info('Sync on shutdown: uploading final manga database changes...');
-            hasMangaUnsyncedChanges = false;
-            try {
-                await mangaSyncUp(mangaDb, remoteFolder);
-            }
-            catch (e) {
-                logger.error({ err: e }, 'Final manga sync on shutdown failed');
-            }
-        }
-        if (hasTvUnsyncedChanges) {
-            logger.info('Sync on shutdown: uploading final TV database changes...');
-            hasTvUnsyncedChanges = false;
-            try {
-                await tvSyncUp(tvDb, remoteFolder);
-            }
-            catch (e) {
-                logger.error({ err: e }, 'Final TV sync on shutdown failed');
-            }
-        }
-        if (hasAsmrUnsyncedChanges) {
-            logger.info('Sync on shutdown: uploading final ASMR database changes...');
-            hasAsmrUnsyncedChanges = false;
+        const kindFinalError = {
+            anime: 'Final sync on shutdown failed',
+            manga: 'Final manga sync on shutdown failed',
+            tv: 'Final TV sync on shutdown failed',
+            asmr: 'Final ASMR sync on shutdown failed',
+        };
+        for (const kind of Object.keys(KIND_SYNC)) {
+            if (!unsynced[kind])
+                continue;
+            logger.info(`Sync on shutdown: uploading final ${kindDbLabel[kind]} changes...`);
+            unsynced[kind] = false;
             try {
-                await asmrSyncUp(asmrDb, remoteFolder);
+                await syncUp(kindDbs()[kind], kind, remoteFolder);
             }
             catch (e) {
-                logger.error({ err: e }, 'Final ASMR sync on shutdown failed');
+                logger.error({ err: e }, kindFinalError[kind]);
             }
         }
         await waitForSync();