@serifpersia/dango 3.3.8 → 3.4.0

package/server/dist/lib/migration.js

@@ -1,4 +1,4 @@
-import { performWriteTransaction } from '../sync.js';
+import { performWriteTransactionAsync } from '../sync.js';
 import { searchAnilistByTitle, getShowMetaById } from './anilist.js';
 import { isTempShowId } from './temp-ids.js';
 import { WatchlistRepository } from '../repositories/watchlist.repository.js';
@@ -7,17 +7,13 @@ import { dbGet, dbRun } from '../utils/db-utils.js';
 import logger from '../logger.js';
 const inFlightMigrations = new Map();
 async function consolidateFromNumeric(db, numericId) {
-    // Check if this numeric ID might be a MAL alias that should redirect to the canonical AniList ID
     const metaRow = dbGet(db, 'SELECT anilistId FROM shows_meta WHERE id = ? AND anilistId IS NOT NULL', [numericId]);
-    // Determine the true anilistId for this numeric ID
     let trueAnilistId;
     if (metaRow?.anilistId != null && String(metaRow.anilistId) !== numericId) {
-        // shows_meta already has a different anilistId — this is clearly a MAL alias
         trueAnilistId = metaRow.anilistId;
     }
     else if (!metaRow) {
-        // No local shows_meta — only verify via AniList if there's existing data that could be a MAL alias
-        if (WatchlistRepository.exists(db, numericId)) {
+        if (await WatchlistRepository.exists(db, numericId)) {
             const meta = await getShowMetaById(numericId);
             if (meta?.anilistId && meta.anilistId !== parseInt(numericId)) {
                 trueAnilistId = meta.anilistId;
@@ -26,12 +22,11 @@ async function consolidateFromNumeric(db, numericId) {
     }
     if (trueAnilistId) {
         const canonicalId = String(trueAnilistId);
-        if (WatchlistRepository.exists(db, numericId)) {
-            // MAL alias is in the watchlist — migrate all entries to the canonical AniList ID
+        if (await WatchlistRepository.exists(db, numericId)) {
             logger.info({ aliasId: numericId, canonicalId }, 'Migrating watchlist from MAL alias to canonical ID');
-            await performWriteTransaction(db, (tx) => {
-                const aliasWatchlist = WatchlistRepository.getById(tx, numericId);
-                const aliasShowsMeta = ShowsMetaRepository.getById(tx, numericId);
+            await performWriteTransactionAsync(db, async (tx) => {
+                const aliasWatchlist = await WatchlistRepository.getById(tx, numericId);
+                const aliasShowsMeta = await ShowsMetaRepository.getById(tx, numericId);
                 tx.run('UPDATE OR IGNORE watchlist SET id = ?, thumbnail = ? WHERE id = ?', [
                     canonicalId,
                     aliasWatchlist?.thumbnail || '',
@@ -70,8 +65,7 @@ async function consolidateFromNumeric(db, numericId) {
             db.scheduleSave();
             return canonicalId;
         }
-        // Not in watchlist — check if canonical ID is in the watchlist and save a mapping
-        if (WatchlistRepository.exists(db, canonicalId)) {
+        if (await WatchlistRepository.exists(db, canonicalId)) {
             const existing = dbGet(db, 'SELECT numericId FROM legacy_id_mapping WHERE legacyId = ?', [numericId]);
             if (!existing || existing.numericId !== canonicalId) {
                 dbRun(db, 'INSERT OR REPLACE INTO legacy_id_mapping (legacyId, numericId) VALUES (?, ?)', [
@@ -84,15 +78,13 @@ async function consolidateFromNumeric(db, numericId) {
             return canonicalId;
         }
     }
-    if (WatchlistRepository.exists(db, numericId))
+    if (await WatchlistRepository.exists(db, numericId))
         return numericId;
     let legacyId;
-    // 1. Check legacy_id_mapping for a legacy ID in the watchlist that maps to this numeric ID
     const legacyRow = dbGet(db, 'SELECT legacyId FROM legacy_id_mapping WHERE numericId = ? AND legacyId IN (SELECT id FROM watchlist)', [numericId]);
     if (legacyRow) {
         legacyId = legacyRow.legacyId;
     }
-    // 2. If not found, check shows_meta by anilistId where the entry's id IS in the watchlist
     if (!legacyId && trueAnilistId) {
         const metaByAnilist = dbGet(db, 'SELECT id FROM shows_meta WHERE anilistId = ? AND id IN (SELECT id FROM watchlist)', [trueAnilistId]);
         if (metaByAnilist) {
@@ -103,9 +95,9 @@ async function consolidateFromNumeric(db, numericId) {
         return numericId;
     logger.info({ legacyId, numericId }, 'Consolidating watchlist entry from legacy to numeric ID');
     const aniListId = parseInt(numericId);
-    await performWriteTransaction(db, (tx) => {
-        const legacyWatchlist = WatchlistRepository.getById(tx, legacyId);
-        const legacyShowsMeta = ShowsMetaRepository.getById(tx, legacyId);
+    await performWriteTransactionAsync(db, async (tx) => {
+        const legacyWatchlist = await WatchlistRepository.getById(tx, legacyId);
+        const legacyShowsMeta = await ShowsMetaRepository.getById(tx, legacyId);
         tx.run('UPDATE OR IGNORE watchlist SET id = ?, thumbnail = ? WHERE id = ?', [
             numericId,
             legacyWatchlist?.thumbnail || '',
@@ -150,7 +142,6 @@ async function migrateId(db, legacyId) {
         return consolidateFromNumeric(db, legacyId);
     }
     try {
-        // 1. Check if mapping already exists
         const mapping = dbGet(db, 'SELECT numericId FROM legacy_id_mapping WHERE legacyId = ?', [legacyId]);
         if (mapping) {
             const mappedMeta = (await ShowsMetaRepository.getById(db, mapping.numericId));
@@ -158,9 +149,9 @@ async function migrateId(db, legacyId) {
             if (!canonicalId || canonicalId === mapping.numericId) {
                 return consolidateFromNumeric(db, mapping.numericId);
             }
-            await performWriteTransaction(db, (tx) => {
-                const legacyWatchlist = WatchlistRepository.getById(tx, mapping.numericId);
-                const legacyShowsMeta = ShowsMetaRepository.getById(tx, mapping.numericId);
+            await performWriteTransactionAsync(db, async (tx) => {
+                const legacyWatchlist = await WatchlistRepository.getById(tx, mapping.numericId);
+                const legacyShowsMeta = await ShowsMetaRepository.getById(tx, mapping.numericId);
                 tx.run('UPDATE OR IGNORE watchlist SET id = ?, thumbnail = ? WHERE id = ?', [
                     canonicalId,
                     legacyWatchlist?.thumbnail || '',
@@ -203,9 +194,7 @@ async function migrateId(db, legacyId) {
             logger.info({ legacyId, previousId: mapping.numericId, newId: canonicalId }, 'Canonicalized migrated show ID');
             return canonicalId;
         }
-        // 2. We need to find the title/name of the show
         let showName;
-        // Try shows_meta by direct ID or anilistId
         const localMeta = (await ShowsMetaRepository.getById(db, legacyId));
         if (localMeta && localMeta.name) {
             showName = localMeta.name;
@@ -216,7 +205,6 @@ async function migrateId(db, legacyId) {
                 showName = metaByAnilist.name;
             }
             else {
-                // Try watchlist
                 const watchlistEntry = await WatchlistRepository.getById(db, legacyId);
                 if (watchlistEntry && watchlistEntry.name) {
                     showName = watchlistEntry.name;
@@ -227,7 +215,6 @@ async function migrateId(db, legacyId) {
             logger.warn({ id: legacyId }, 'No show name found for legacy ID migration');
             return legacyId;
         }
-        // 3. Search AniList by title
         const aniListShow = await searchAnilistByTitle(showName);
         if (!aniListShow) {
             logger.warn({ id: legacyId, showName }, 'No AniList match found for legacy ID migration');
@@ -242,17 +229,16 @@ async function migrateId(db, legacyId) {
         catch {
             newThumbnail = undefined;
         }
-        // 4. Perform the DB updates across all tables atomically
-        await performWriteTransaction(db, (tx) => {
+        await performWriteTransactionAsync(db, async (tx) => {
             tx.run('INSERT OR REPLACE INTO legacy_id_mapping (legacyId, numericId) VALUES (?, ?)', [
                 legacyId,
                 newId,
             ]);
-            const legacyWatchlist = WatchlistRepository.getById(tx, legacyId);
+            const legacyWatchlist = await WatchlistRepository.getById(tx, legacyId);
             if (legacyWatchlist) {
-                const newWatchlistExists = WatchlistRepository.getById(tx, newId);
+                const newWatchlistExists = await WatchlistRepository.getById(tx, newId);
                 if (newWatchlistExists) {
-                    WatchlistRepository.delete(tx, legacyId);
+                    await WatchlistRepository.delete(tx, legacyId);
                 }
                 else {
                     tx.run('UPDATE watchlist SET id = ?, thumbnail = ? WHERE id = ?', [
@@ -262,9 +248,9 @@ async function migrateId(db, legacyId) {
                     ]);
                 }
             }
-            const legacyShowsMeta = ShowsMetaRepository.getById(tx, legacyId);
+            const legacyShowsMeta = await ShowsMetaRepository.getById(tx, legacyId);
             if (legacyShowsMeta) {
-                const newShowsMetaExists = ShowsMetaRepository.getById(tx, newId);
+                const newShowsMetaExists = await ShowsMetaRepository.getById(tx, newId);
                 if (newShowsMetaExists) {
                     tx.run('DELETE FROM shows_meta WHERE id = ?', [legacyId]);
                 }

package/server/dist/lib/offline-db.js

@@ -122,8 +122,8 @@ class OfflineDb {
             ensureTable(db);
             this.loadCache(db);
             log.info(`OfflineDb loaded ${this.malToEntry.size} MAL mappings from SQLite`);
-            const wasInterrupted = SettingsRepository.getByKey(db, 'offlineDbLastStatus')?.value === 'updating';
-            const autoUpdateSetting = SettingsRepository.getByKey(db, 'offlineDbAutoUpdateEnabled');
+            const wasInterrupted = (await SettingsRepository.getByKey(db, 'offlineDbLastStatus'))?.value === 'updating';
+            const autoUpdateSetting = await SettingsRepository.getByKey(db, 'offlineDbAutoUpdateEnabled');
             const autoUpdateEnabled = !autoUpdateSetting || autoUpdateSetting.value !== 'false';
             this.backfillShowsMetaGenres(db);
             if (this.malToEntry.size === 0) {
@@ -132,17 +132,17 @@ class OfflineDb {
                     log.warn({ err: err?.message }, 'Background offline database download failed');
                 });
             }
-            else if (wasInterrupted && autoUpdateEnabled && this.interruptedRetryDue(db)) {
+            else if (wasInterrupted && autoUpdateEnabled && (await this.interruptedRetryDue(db))) {
                 log.info('Previous offline database refresh was interrupted. Retrying in background...');
-                SettingsRepository.upsert(db, 'offlineDbLastStatus', 'idle');
-                SettingsRepository.upsert(db, 'offlineDbLastMessage', 'Previous refresh was interrupted by a restart. Retrying automatically...');
+                await SettingsRepository.upsert(db, 'offlineDbLastStatus', 'idle');
+                await SettingsRepository.upsert(db, 'offlineDbLastMessage', 'Previous refresh was interrupted by a restart. Retrying automatically...');
                 this.refreshDatabase(db).catch((err) => {
                     log.warn({ err: err?.message }, 'Interrupted offline database retry failed');
                 });
             }
             else if (wasInterrupted) {
-                SettingsRepository.upsert(db, 'offlineDbLastStatus', 'idle');
-                SettingsRepository.upsert(db, 'offlineDbLastMessage', 'Previous refresh was interrupted by a restart. Trigger an update to retry.');
+                await SettingsRepository.upsert(db, 'offlineDbLastStatus', 'idle');
+                await SettingsRepository.upsert(db, 'offlineDbLastMessage', 'Previous refresh was interrupted by a restart. Trigger an update to retry.');
             }
             this.isInitialized = true;
         }
@@ -214,34 +214,34 @@ class OfflineDb {
     getMalIdByAnilist(anilistId) {
         return this.anilistToMal.get(anilistId) ?? null;
     }
-    getOfflineDbInfo(db) {
-        const get = (key) => SettingsRepository.getByKey(db, key)?.value ?? null;
-        const autoUpdate = get('offlineDbAutoUpdateEnabled');
-        const lastStatus = get('offlineDbLastStatus');
-        const entryCount = Number(get('offlineDbEntryCount') ?? this.malToEntry.size) || 0;
+    async getOfflineDbInfo(db) {
+        const get = async (key) => (await SettingsRepository.getByKey(db, key))?.value ?? null;
+        const autoUpdate = await get('offlineDbAutoUpdateEnabled');
+        const lastStatus = (await get('offlineDbLastStatus'));
+        const entryCount = Number((await get('offlineDbEntryCount')) ?? this.malToEntry.size) || 0;
         return {
             totalMapped: this.malToEntry.size,
             totalMalMapped: this.malToEntry.size,
             isInitialized: this.isInitialized,
             isRefreshing: this.isRefreshing,
             autoUpdateEnabled: autoUpdate ? autoUpdate !== 'false' : true,
-            lastCheckedAt: get('offlineDbLastCheckedAt'),
-            lastUpdatedAt: get('offlineDbLastUpdatedAt'),
+            lastCheckedAt: await get('offlineDbLastCheckedAt'),
+            lastUpdatedAt: await get('offlineDbLastUpdatedAt'),
             lastStatus: lastStatus || (this.isRefreshing ? 'updating' : 'idle'),
-            lastMessage: get('offlineDbLastMessage'),
-            sourceUrl: get('offlineDbSourceUrl'),
-            releaseTag: get('offlineDbReleaseTag'),
-            contentSha256: get('offlineDbContentSha256'),
+            lastMessage: await get('offlineDbLastMessage'),
+            sourceUrl: await get('offlineDbSourceUrl'),
+            releaseTag: await get('offlineDbReleaseTag'),
+            contentSha256: await get('offlineDbContentSha256'),
             entryCount,
             schemaVersion: SCHEMA_VERSION,
             nextDueAt: latestSaturdayUtc().toISOString(),
         };
     }
-    checkWeeklyUpdateDue(db) {
-        const autoUpdate = SettingsRepository.getByKey(db, 'offlineDbAutoUpdateEnabled');
+    async checkWeeklyUpdateDue(db) {
+        const autoUpdate = await SettingsRepository.getByKey(db, 'offlineDbAutoUpdateEnabled');
         if (autoUpdate && autoUpdate.value === 'false')
             return false;
-        const lastChecked = SettingsRepository.getByKey(db, 'offlineDbLastCheckedAt');
+        const lastChecked = await SettingsRepository.getByKey(db, 'offlineDbLastCheckedAt');
         if (!lastChecked?.value)
             return true;
         const lastCheckedTime = new Date(lastChecked.value).getTime();
@@ -249,8 +249,8 @@ class OfflineDb {
             return true;
         return lastCheckedTime < latestSaturdayUtc().getTime();
     }
-    interruptedRetryDue(db) {
-        const lastChecked = SettingsRepository.getByKey(db, 'offlineDbLastCheckedAt');
+    async interruptedRetryDue(db) {
+        const lastChecked = await SettingsRepository.getByKey(db, 'offlineDbLastCheckedAt');
         if (!lastChecked?.value)
             return true;
         const lastCheckedTime = new Date(lastChecked.value).getTime();
@@ -276,9 +276,9 @@ class OfflineDb {
         }
         this.isRefreshing = true;
         const startedAt = Date.now();
-        SettingsRepository.upsert(db, 'offlineDbLastStatus', 'updating');
-        SettingsRepository.upsert(db, 'offlineDbLastCheckedAt', new Date().toISOString());
-        SettingsRepository.upsert(db, 'offlineDbLastMessage', 'Downloading and parsing database...');
+        await SettingsRepository.upsert(db, 'offlineDbLastStatus', 'updating');
+        await SettingsRepository.upsert(db, 'offlineDbLastCheckedAt', new Date().toISOString());
+        await SettingsRepository.upsert(db, 'offlineDbLastMessage', 'Downloading and parsing database...');
         try {
             let text = null;
             let sourceUrl = null;
@@ -302,7 +302,7 @@ class OfflineDb {
             if (!text)
                 throw lastErr || new Error('Could not download anime-offline-database from any source');
             const sha256 = crypto.createHash('sha256').update(text).digest('hex');
-            const storedSha = SettingsRepository.getByKey(db, 'offlineDbContentSha256')?.value;
+            const storedSha = (await SettingsRepository.getByKey(db, 'offlineDbContentSha256'))?.value;
             const data = JSON.parse(text).data;
             log.info(`Parsing ${data.length} entries from anime-offline-database...`);
             const anilistRegex = /anilist\.co\/anime\/(\d+)/i;
@@ -375,22 +375,22 @@ class OfflineDb {
             this.loadCache(db);
             this.backfillShowsMetaGenres(db);
             const releaseTag = sourceUrl?.includes('/releases/') ? 'latest' : 'raw';
-            SettingsRepository.upsert(db, 'offlineDbLastStatus', 'success');
-            SettingsRepository.upsert(db, 'offlineDbLastUpdatedAt', new Date().toISOString());
-            SettingsRepository.upsert(db, 'offlineDbSourceUrl', sourceUrl ?? '');
-            SettingsRepository.upsert(db, 'offlineDbReleaseTag', releaseTag);
-            SettingsRepository.upsert(db, 'offlineDbContentSha256', sha256);
-            SettingsRepository.upsert(db, 'offlineDbEntryCount', String(parsedEntries.length));
+            await SettingsRepository.upsert(db, 'offlineDbLastStatus', 'success');
+            await SettingsRepository.upsert(db, 'offlineDbLastUpdatedAt', new Date().toISOString());
+            await SettingsRepository.upsert(db, 'offlineDbSourceUrl', sourceUrl ?? '');
+            await SettingsRepository.upsert(db, 'offlineDbReleaseTag', releaseTag);
+            await SettingsRepository.upsert(db, 'offlineDbContentSha256', sha256);
+            await SettingsRepository.upsert(db, 'offlineDbEntryCount', String(parsedEntries.length));
             const skipped = storedSha === sha256;
-            SettingsRepository.upsert(db, 'offlineDbLastMessage', `Updated ${parsedEntries.length} entries in ${Math.round((Date.now() - startedAt) / 1000)}s${skipped ? ' (unchanged upstream hash)' : ''}.`);
+            await SettingsRepository.upsert(db, 'offlineDbLastMessage', `Updated ${parsedEntries.length} entries in ${Math.round((Date.now() - startedAt) / 1000)}s${skipped ? ' (unchanged upstream hash)' : ''}.`);
             log.info(`OfflineDb refresh completed: ${parsedEntries.length} entries from ${sourceUrl}`);
             return { success: true, count: parsedEntries.length };
         }
         catch (err) {
             const errMsg = err.message || 'Failed to refresh offline database';
             log.error({ err }, 'Failed to refresh anime-offline-database');
-            SettingsRepository.upsert(db, 'offlineDbLastStatus', 'failed');
-            SettingsRepository.upsert(db, 'offlineDbLastMessage', errMsg);
+            await SettingsRepository.upsert(db, 'offlineDbLastStatus', 'failed');
+            await SettingsRepository.upsert(db, 'offlineDbLastMessage', errMsg);
             return { success: false, count: this.malToEntry.size, error: errMsg };
         }
         finally {

package/server/dist/lib/tracker/manga-sync.service.js

@@ -1,7 +1,7 @@
 import { AniListTracker } from './anilist-tracker.js';
 import { MangaLibraryRepository, MangaProgressRepository, } from '../../repositories/manga.repository.js';
 import { SettingsRepository } from '../../repositories/settings.repository.js';
-import { performMangaWriteTransaction, performWriteTransaction } from '../../sync.js';
+import { performMangaWriteTransactionAsync, performWriteTransactionAsync } from '../../sync.js';
 import logger from '../../logger.js';
 import { searchAnilistMangaByTitle, getMangaMetaById, getMangaMetaByMalId } from '../anilist.js';
 import { fetchMalMangaList, mapMalMangaStatusCode } from '../mal.js';
@@ -557,19 +557,19 @@ export async function syncAniListManga(db, mangaDb, opts = {}) {
         progressRows.length > 0 ||
         libraryDeletes.length > 0 ||
         newLinks.length > 0) {
-        await performMangaWriteTransaction(mangaDb, (tx) => {
+        await performMangaWriteTransactionAsync(mangaDb, async (tx) => {
             for (const item of libraryUpserts) {
-                MangaLibraryRepository.upsert(tx, item);
+                await MangaLibraryRepository.upsert(tx, item);
             }
             for (const link of newLinks) {
-                MangaLibraryRepository.setAnilistId(tx, link.id, link.anilistId, 'search');
+                await MangaLibraryRepository.setAnilistId(tx, link.id, link.anilistId, 'search');
             }
             for (const p of progressPointers) {
-                MangaLibraryRepository.setProgressPointer(tx, p.id, p.chapterNumber);
+                await MangaLibraryRepository.setProgressPointer(tx, p.id, p.chapterNumber);
             }
             for (const p of progressRows) {
-                MangaProgressRepository.deleteSyntheticChapters(tx, p.mangaId, p.chapterId);
-                MangaProgressRepository.upsert(tx, {
+                await MangaProgressRepository.deleteSyntheticChapters(tx, p.mangaId, p.chapterId);
+                await MangaProgressRepository.upsert(tx, {
                     mangaId: p.mangaId,
                     chapterId: p.chapterId,
                     chapterNumber: p.chapterNumber,
@@ -581,8 +581,8 @@ export async function syncAniListManga(db, mangaDb, opts = {}) {
                 });
             }
             for (const id of libraryDeletes) {
-                MangaLibraryRepository.delete(tx, id);
-                MangaProgressRepository.deleteByManga(tx, id);
+                await MangaLibraryRepository.delete(tx, id);
+                await MangaProgressRepository.deleteByManga(tx, id);
             }
         });
     }
@@ -596,8 +596,8 @@ export async function syncAniListManga(db, mangaDb, opts = {}) {
                     mergedState[k] = v;
             }
             const snapshot = JSON.stringify(mergedState);
-            await performWriteTransaction(db, (tx) => {
-                SettingsRepository.upsert(tx, MANGA_SYNC_STATE_KEY, snapshot);
+            await performWriteTransactionAsync(db, async (tx) => {
+                await SettingsRepository.upsert(tx, MANGA_SYNC_STATE_KEY, snapshot);
             });
         }
         catch (err) {
@@ -619,19 +619,19 @@ export async function insertMangaImportEntries(db, mangaDb, items, eraseAnilistR
         return 0;
     const now = Math.floor(Date.now() / 1000);
     const syncState = await readMangaSyncState(db);
-    await performMangaWriteTransaction(mangaDb, (tx) => {
+    await performMangaWriteTransactionAsync(mangaDb, async (tx) => {
         if (eraseAnilistRows) {
-            for (const row of MangaLibraryRepository.getAll(tx)) {
+            for (const row of await MangaLibraryRepository.getAll(tx)) {
                 if (String(row.provider).toLowerCase() === MANGA_PROVIDER) {
-                    MangaLibraryRepository.delete(tx, row.id);
-                    MangaProgressRepository.deleteByManga(tx, row.id);
+                    await MangaLibraryRepository.delete(tx, row.id);
+                    await MangaProgressRepository.deleteByManga(tx, row.id);
                 }
             }
         }
         for (const item of items) {
             const id = buildAnilistMangaId(item.mediaId);
             const status = mangaImportStatusOrDefault(item.status);
-            MangaLibraryRepository.upsert(tx, {
+            await MangaLibraryRepository.upsert(tx, {
                 id,
                 provider: MANGA_PROVIDER,
                 mangaId: String(item.mediaId),
@@ -642,10 +642,10 @@ export async function insertMangaImportEntries(db, mangaDb, items, eraseAnilistR
                 anilistIdSource: 'anilist',
             });
             if (item.progress > 0) {
-                MangaLibraryRepository.setProgressPointer(tx, id, String(item.progress));
+                await MangaLibraryRepository.setProgressPointer(tx, id, String(item.progress));
                 const chapterId = buildSyntheticChapterId(item.progress);
-                MangaProgressRepository.deleteSyntheticChapters(tx, id, chapterId);
-                MangaProgressRepository.upsert(tx, {
+                await MangaProgressRepository.deleteSyntheticChapters(tx, id, chapterId);
+                await MangaProgressRepository.upsert(tx, {
                     mangaId: id,
                     chapterId,
                     chapterNumber: String(item.progress),
@@ -664,8 +664,8 @@ export async function insertMangaImportEntries(db, mangaDb, items, eraseAnilistR
     });
     try {
         const snapshot = JSON.stringify(syncState);
-        await performWriteTransaction(db, (tx) => {
-            SettingsRepository.upsert(tx, MANGA_SYNC_STATE_KEY, snapshot);
+        await performWriteTransactionAsync(db, async (tx) => {
+            await SettingsRepository.upsert(tx, MANGA_SYNC_STATE_KEY, snapshot);
         });
     }
     catch (err) {

package/server/dist/lib/tracker/sync.service.js

@@ -4,7 +4,7 @@ import { WatchedEpisodesRepository } from '../../repositories/watched-episodes.r
 import { ShowsMetaRepository } from '../../repositories/shows-meta.repository.js';
 import { SettingsRepository } from '../../repositories/settings.repository.js';
 import { NotificationsRepository } from '../../repositories/notifications.repository.js';
-import { performWriteTransaction } from '../../sync.js';
+import { performWriteTransactionAsync } from '../../sync.js';
 import { dbGet } from '../../utils/db-utils.js';
 import logger from '../../logger.js';
 import { fetchMalUserList } from '../mal.js';
@@ -242,16 +242,16 @@ export async function syncAniList(db) {
         watchedInserts.length > 0 ||
         watchlistDeletes.length > 0 ||
         Object.keys(stateUpdates).length > 0) {
-        await performWriteTransaction(db, (tx) => {
+        await performWriteTransactionAsync(db, async (tx) => {
             for (const item of watchlistUpserts) {
-                WatchlistRepository.upsert(tx, item);
+                await WatchlistRepository.upsert(tx, item);
             }
             for (const meta of metaUpserts) {
-                ShowsMetaRepository.upsert(tx, meta);
+                await ShowsMetaRepository.upsert(tx, meta);
             }
             for (const w of watchedInserts) {
                 for (let ep = w.from; ep <= w.to; ep++) {
-                    WatchedEpisodesRepository.insertIfMissing(tx, {
+                    await WatchedEpisodesRepository.insertIfMissing(tx, {
                         showId: w.showId,
                         episodeNumber: String(ep),
                         watchedAt: toSqliteDatetime(w.updatedAt),
@@ -259,9 +259,9 @@ export async function syncAniList(db) {
                 }
             }
             for (const id of watchlistDeletes) {
-                WatchlistRepository.delete(tx, id);
-                WatchedEpisodesRepository.deleteByShow(tx, id);
-                NotificationsRepository.deleteByShow(tx, id);
+                await WatchlistRepository.delete(tx, id);
+                await WatchedEpisodesRepository.deleteByShow(tx, id);
+                await NotificationsRepository.deleteByShow(tx, id);
             }
             const mergedState = { ...syncState };
             for (const [k, v] of Object.entries(stateUpdates)) {
@@ -270,7 +270,7 @@ export async function syncAniList(db) {
                 else
                     mergedState[k] = v;
             }
-            SettingsRepository.upsert(tx, SYNC_STATE_KEY, JSON.stringify(mergedState));
+            await SettingsRepository.upsert(tx, SYNC_STATE_KEY, JSON.stringify(mergedState));
         });
     }
     return summary;
@@ -300,13 +300,13 @@ export async function importFromUsername(db, username, erase = false) {
         return 0;
     const now = Math.floor(Date.now() / 1000);
     const syncState = await readSyncState(db);
-    await performWriteTransaction(db, (tx) => {
+    await performWriteTransactionAsync(db, async (tx) => {
         if (erase)
-            SettingsRepository.clearWatchlist(tx);
+            await SettingsRepository.clearWatchlist(tx);
         for (const remote of entries) {
             const showId = String(remote.mediaId);
             const title = remote.title.english || remote.title.romaji || `Anime #${remote.mediaId}`;
-            WatchlistRepository.upsert(tx, {
+            await WatchlistRepository.upsert(tx, {
                 id: showId,
                 name: title,
                 thumbnail: remote.coverImage ?? '',
@@ -315,7 +315,7 @@ export async function importFromUsername(db, username, erase = false) {
                 englishName: remote.title.english ?? '',
                 type: 'TV',
             });
-            ShowsMetaRepository.upsert(tx, {
+            await ShowsMetaRepository.upsert(tx, {
                 id: showId,
                 name: title,
                 thumbnail: remote.coverImage,
@@ -326,7 +326,7 @@ export async function importFromUsername(db, username, erase = false) {
             });
             if (remote.progress > 0) {
                 for (let ep = 1; ep <= remote.progress; ep++) {
-                    WatchedEpisodesRepository.insertIfMissing(tx, {
+                    await WatchedEpisodesRepository.insertIfMissing(tx, {
                         showId,
                         episodeNumber: String(ep),
                         watchedAt: toSqliteDatetime(remote.updatedAt),
@@ -335,7 +335,7 @@ export async function importFromUsername(db, username, erase = false) {
             }
             syncState[showId] = { lastSyncedAt: now, remoteUpdatedAt: remote.updatedAt };
         }
-        SettingsRepository.upsert(tx, SYNC_STATE_KEY, JSON.stringify(syncState));
+        await SettingsRepository.upsert(tx, SYNC_STATE_KEY, JSON.stringify(syncState));
     });
     return entries.length;
 }
@@ -458,11 +458,11 @@ export async function importFromMalUsername(db, username, options = {}) {
         }
     }
     if (shows.length > 0 || erase) {
-        await performWriteTransaction(db, (tx) => {
+        await performWriteTransactionAsync(db, async (tx) => {
             if (erase)
-                SettingsRepository.clearWatchlist(tx);
+                await SettingsRepository.clearWatchlist(tx);
             for (const show of shows) {
-                WatchlistRepository.upsert(tx, {
+                await WatchlistRepository.upsert(tx, {
                     id: show.id,
                     name: show.name,
                     thumbnail: show.thumbnail ?? '',
@@ -474,7 +474,7 @@ export async function importFromMalUsername(db, username, options = {}) {
             }
             for (const meta of metas) {
                 if (meta.thumbnail || meta.type || meta.genres) {
-                    ShowsMetaRepository.upsert(tx, {
+                    await ShowsMetaRepository.upsert(tx, {
                         id: meta.id,
                         thumbnail: meta.thumbnail,
                         type: meta.type,
@@ -484,7 +484,7 @@ export async function importFromMalUsername(db, username, options = {}) {
             }
             for (const w of watched) {
                 for (let ep = 1; ep <= w.progress; ep++) {
-                    WatchedEpisodesRepository.insertIfMissing(tx, {
+                    await WatchedEpisodesRepository.insertIfMissing(tx, {
                         showId: w.showId,
                         episodeNumber: String(ep),
                     });

package/server/dist/lib/translate.js

@@ -0,0 +1,79 @@
+import { AppCache } from '../utils/cache.utils.js';
+import { parseJsonBody } from '../utils/http.utils.js';
+const cache = new AppCache({
+    ttlSeconds: 7 * 24 * 60 * 60,
+    maxKeys: 5000,
+});
+function toTitleCase(s) {
+    return s
+        .split(' ')
+        .map((w, i) => {
+        if (i !== 0 &&
+            ['x', 'and', 'or', 'the', 'a', 'an', 'of', 'in', 'on', 'with'].includes(w.toLowerCase())) {
+            return w.toLowerCase();
+        }
+        return w.charAt(0).toUpperCase() + w.slice(1);
+    })
+        .join(' ')
+        .replace(/\bX\b/g, 'x');
+}
+function normalize(s) {
+    const t = s.trim();
+    if (!t)
+        return t;
+    return toTitleCase(t);
+}
+export async function translateTexts(texts, source, target) {
+    const jobs = texts.map((t) => String(t).trim()).filter(Boolean);
+    const result = {};
+    const toFetch = [];
+    for (const t of jobs) {
+        const key = `${source}:${target}:${t}`;
+        const cached = cache.get(key);
+        if (cached)
+            result[t] = cached;
+        else
+            toFetch.push(t);
+    }
+    if (toFetch.length > 0) {
+        const chunks = [];
+        for (let i = 0; i < toFetch.length; i += 15)
+            chunks.push(toFetch.slice(i, i + 15));
+        for (const chunk of chunks) {
+            const q = chunk.join('\n');
+            const url = `https://clients5.google.com/translate_a/t?client=dict-chrome-ex&sl=${encodeURIComponent(source)}&tl=${encodeURIComponent(target)}&dt=t&q=${encodeURIComponent(q)}`;
+            try {
+                const r = await fetch(url, {
+                    headers: { 'User-Agent': 'Mozilla/5.0' },
+                    signal: AbortSignal.timeout(5000),
+                });
+                if (!r.ok)
+                    throw new Error(`translate ${r.status}`);
+                const data = (await parseJsonBody(r));
+                let translated = '';
+                if (Array.isArray(data) && typeof data[0] === 'string') {
+                    translated = data[0];
+                }
+                else if (Array.isArray(data) && Array.isArray(data[0])) {
+                    const outer = data;
+                    translated = outer[0]?.map((p) => p[0]).join('') || '';
+                }
+                const parts = translated.split('\n');
+                chunk.forEach((orig, i) => {
+                    const trans = (parts[i] ?? '').trim();
+                    const norm = trans ? normalize(trans) : orig;
+                    result[orig] = norm;
+                    cache.set(`${source}:${target}:${orig}`, norm);
+                });
+            }
+            catch {
+                for (const orig of chunk) {
+                    if (!result[orig])
+                        result[orig] = orig;
+                }
+            }
+            await new Promise((r) => setTimeout(r, 80));
+        }
+    }
+    return result;
+}