@serifpersia/dango 3.3.9 → 3.4.0

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

@@ -1,4 +1,6 @@
-import { dbAll, dbGet, dbRun } from '../utils/db-utils.js';
+import { eq, inArray, sql } from 'drizzle-orm';
+import { getDrizzle } from '../db/drizzle.js';
+import { mangaLibrary, mangaProgress } from '../db/schema-manga.js';
 export const MANGA_STATUSES = [
     'Reading',
     'Completed',
@@ -10,144 +12,134 @@ export function buildMangaId(provider, mangaId) {
     return `${provider.toLowerCase()}:${mangaId}`;
 }
 export const MangaLibraryRepository = {
-    getById: (db, id) => dbGet(db, 'SELECT * FROM manga_library WHERE id = ?', [id]),
-    exists: (db, id) => {
-        const row = dbGet(db, 'SELECT EXISTS(SELECT 1 FROM manga_library WHERE id = ?) as inLibrary', [id]);
-        return !!(row && row.inLibrary);
+    getById: async (db, id) => {
+        const rows = await getDrizzle(db).all(sql `SELECT * FROM manga_library WHERE id = ${id}`);
+        return rows[0];
+    },
+    exists: async (db, id) => {
+        const rows = await getDrizzle(db).all(sql `SELECT EXISTS(SELECT 1 FROM manga_library WHERE id = ${id}) as inLibrary`);
+        return !!(rows[0] && rows[0].inLibrary);
     },
     getAll: (db, status, limit, offset) => {
-        let query = 'SELECT * FROM manga_library';
-        const params = [];
+        const q = sql `SELECT * FROM manga_library`;
         if (status && status !== 'All') {
-            query += ' WHERE status = ?';
-            params.push(status);
+            q.append(sql ` WHERE status = ${status}`);
         }
-        query += ' ORDER BY updatedAt DESC';
+        q.append(sql ` ORDER BY updatedAt DESC`);
         if (limit !== undefined && offset !== undefined) {
-            query += ' LIMIT ? OFFSET ?';
-            params.push(limit, offset);
+            q.append(sql ` LIMIT ${limit} OFFSET ${offset}`);
         }
-        return dbAll(db, query, params);
+        return getDrizzle(db).all(q);
     },
-    getCount: (db, status) => {
-        let query = 'SELECT COUNT(*) as total FROM manga_library';
-        const params = [];
+    getCount: async (db, status) => {
         if (status && status !== 'All') {
-            query += ' WHERE status = ?';
-            params.push(status);
+            const rows = await getDrizzle(db).all(sql `SELECT COUNT(*) as total FROM manga_library WHERE status = ${status}`);
+            return rows[0]?.total || 0;
         }
-        const row = dbGet(db, query, params);
-        return row?.total || 0;
+        const rows = await getDrizzle(db).all(sql `SELECT COUNT(*) as total FROM manga_library`);
+        return rows[0]?.total || 0;
+    },
+    getIds: async (db) => {
+        const rows = await getDrizzle(db).all(sql `SELECT id FROM manga_library`);
+        return rows.map((r) => r.id);
     },
-    getIds: (db) => dbAll(db, 'SELECT id FROM manga_library').map((r) => r.id),
-    upsert: (db, data) => dbRun(db, `INSERT INTO manga_library (id, provider, mangaId, title, cover, status, author, altTitle, contentRating, anilistId, anilistIdSource, updatedAt)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, strftime('%s', 'now'))
-       ON CONFLICT(id) DO UPDATE SET
-          provider = COALESCE(NULLIF(EXCLUDED.provider, ''), manga_library.provider),
-          title = COALESCE(NULLIF(EXCLUDED.title, ''), manga_library.title),
-          cover = COALESCE(NULLIF(EXCLUDED.cover, ''), manga_library.cover),
-          status = COALESCE(NULLIF(EXCLUDED.status, ''), manga_library.status),
-          author = COALESCE(NULLIF(EXCLUDED.author, ''), manga_library.author),
-          altTitle = COALESCE(NULLIF(EXCLUDED.altTitle, ''), manga_library.altTitle),
-          contentRating = COALESCE(EXCLUDED.contentRating, manga_library.contentRating),
-          anilistId = COALESCE(EXCLUDED.anilistId, manga_library.anilistId),
-          anilistIdSource = COALESCE(EXCLUDED.anilistIdSource, manga_library.anilistIdSource),
-          updatedAt = strftime('%s', 'now')`, [
-        data.id,
-        data.provider,
-        data.mangaId,
-        data.title,
-        data.cover,
-        data.status,
-        data.author || null,
-        data.altTitle || null,
-        data.contentRating || null,
-        data.anilistId ?? null,
-        data.anilistIdSource ?? null,
-    ]),
+    upsert: (db, data) => getDrizzle(db).run(sql `
+      INSERT INTO manga_library (id, provider, mangaId, title, cover, status, author, altTitle, contentRating, anilistId, anilistIdSource, updatedAt)
+      VALUES (${data.id}, ${data.provider}, ${data.mangaId}, ${data.title}, ${data.cover}, ${data.status}, ${data.author || null}, ${data.altTitle || null}, ${data.contentRating || null}, ${data.anilistId ?? null}, ${data.anilistIdSource ?? null}, strftime('%s', 'now'))
+      ON CONFLICT(id) DO UPDATE SET
+         provider = COALESCE(NULLIF(EXCLUDED.provider, ''), manga_library.provider),
+         title = COALESCE(NULLIF(EXCLUDED.title, ''), manga_library.title),
+         cover = COALESCE(NULLIF(EXCLUDED.cover, ''), manga_library.cover),
+         status = COALESCE(NULLIF(EXCLUDED.status, ''), manga_library.status),
+         author = COALESCE(NULLIF(EXCLUDED.author, ''), manga_library.author),
+         altTitle = COALESCE(NULLIF(EXCLUDED.altTitle, ''), manga_library.altTitle),
+         contentRating = COALESCE(EXCLUDED.contentRating, manga_library.contentRating),
+         anilistId = COALESCE(EXCLUDED.anilistId, manga_library.anilistId),
+         anilistIdSource = COALESCE(EXCLUDED.anilistIdSource, manga_library.anilistIdSource),
+         updatedAt = strftime('%s', 'now')`),
     setAnilistId: (db, id, anilistId, source) => source
-        ? dbRun(db, 'UPDATE manga_library SET anilistId = ?, anilistIdSource = ? WHERE id = ?', [
-            anilistId,
-            source,
-            id,
-        ])
-        : dbRun(db, 'UPDATE manga_library SET anilistId = ? WHERE id = ?', [anilistId, id]),
-    getByAnilistId: (db, anilistId) => dbAll(db, 'SELECT * FROM manga_library WHERE anilistId = ?', [anilistId]),
-    updateStatus: (db, id, status) => dbRun(db, "UPDATE manga_library SET status = ?, updatedAt = strftime('%s', 'now') WHERE id = ?", [status, id]),
+        ? getDrizzle(db)
+            .update(mangaLibrary)
+            .set({ anilistId, anilistIdSource: source })
+            .where(eq(mangaLibrary.id, id))
+        : getDrizzle(db).update(mangaLibrary).set({ anilistId }).where(eq(mangaLibrary.id, id)),
+    getByAnilistId: (db, anilistId) => getDrizzle(db).all(sql `SELECT * FROM manga_library WHERE anilistId = ${anilistId}`),
+    updateStatus: (db, id, status) => getDrizzle(db).run(sql `
+      UPDATE manga_library SET status = ${status}, updatedAt = strftime('%s', 'now') WHERE id = ${id}`),
     updateStatusMany: (db, ids, status) => {
         if (ids.length === 0)
-            return;
-        const placeholders = ids.map(() => '?').join(', ');
-        dbRun(db, `UPDATE manga_library SET status = ?, updatedAt = strftime('%s', 'now') WHERE id IN (${placeholders})`, [status, ...ids]);
+            return Promise.resolve();
+        return getDrizzle(db).run(sql `
+      UPDATE manga_library SET status = ${status}, updatedAt = strftime('%s', 'now') WHERE id IN (${sql.join(ids.map((id) => sql `${id}`), sql `, `)})`);
     },
-    touchProgress: (db, id, progress) => dbRun(db, `UPDATE manga_library SET lastChapterId = ?, lastChapterNumber = ?, lastPage = ?, updatedAt = strftime('%s', 'now') WHERE id = ?`, [progress.chapterId, progress.chapterNumber, progress.page, id]),
-    setProgressPointer: (db, id, chapterNumber) => dbRun(db, `UPDATE manga_library SET lastChapterNumber = ?, updatedAt = strftime('%s', 'now') WHERE id = ?`, [chapterNumber, id]),
-    delete: (db, id) => dbRun(db, 'DELETE FROM manga_library WHERE id = ?', [id]),
+    touchProgress: (db, id, progress) => getDrizzle(db).run(sql `
+      UPDATE manga_library SET lastChapterId = ${progress.chapterId}, lastChapterNumber = ${progress.chapterNumber}, lastPage = ${progress.page}, updatedAt = strftime('%s', 'now') WHERE id = ${id}`),
+    setProgressPointer: (db, id, chapterNumber) => getDrizzle(db).run(sql `
+      UPDATE manga_library SET lastChapterNumber = ${chapterNumber}, updatedAt = strftime('%s', 'now') WHERE id = ${id}`),
+    delete: (db, id) => getDrizzle(db).delete(mangaLibrary).where(eq(mangaLibrary.id, id)),
     deleteMany: (db, ids) => {
         if (ids.length === 0)
-            return;
-        const placeholders = ids.map(() => '?').join(', ');
-        dbRun(db, `DELETE FROM manga_library WHERE id IN (${placeholders})`, ids);
+            return Promise.resolve();
+        return getDrizzle(db).delete(mangaLibrary).where(inArray(mangaLibrary.id, ids));
     },
 };
 export const MangaProgressRepository = {
-    getByManga: (db, mangaId) => dbAll(db, 'SELECT mangaId, chapterId, chapterNumber, page, pageCount, updatedAt FROM manga_progress WHERE mangaId = ? ORDER BY updatedAt DESC', [mangaId]),
-    getChapter: (db, mangaId, chapterId) => dbGet(db, 'SELECT mangaId, chapterId, chapterNumber, page, pageCount, updatedAt FROM manga_progress WHERE mangaId = ? AND chapterId = ?', [mangaId, chapterId]),
-    getLatest: (db, mangaId) => dbGet(db, 'SELECT mangaId, chapterId, chapterNumber, page, pageCount, updatedAt FROM manga_progress WHERE mangaId = ? ORDER BY updatedAt DESC LIMIT 1', [mangaId]),
-    upsert: (db, data) => dbRun(db, `INSERT INTO manga_progress (mangaId, chapterId, chapterNumber, page, pageCount, title, cover, provider, altTitle, contentRating, updatedAt)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, strftime('%s', 'now'))
-       ON CONFLICT(mangaId, chapterId) DO UPDATE SET
-          chapterNumber = COALESCE(NULLIF(EXCLUDED.chapterNumber, ''), manga_progress.chapterNumber),
-          page = EXCLUDED.page,
-          pageCount = EXCLUDED.pageCount,
-          title = COALESCE(EXCLUDED.title, manga_progress.title),
-          cover = COALESCE(EXCLUDED.cover, manga_progress.cover),
-          provider = COALESCE(EXCLUDED.provider, manga_progress.provider),
-          altTitle = COALESCE(EXCLUDED.altTitle, manga_progress.altTitle),
-          contentRating = COALESCE(EXCLUDED.contentRating, manga_progress.contentRating),
-          updatedAt = strftime('%s', 'now')`, [
-        data.mangaId,
-        data.chapterId,
-        data.chapterNumber,
-        data.page,
-        data.pageCount,
-        data.title ?? null,
-        data.cover ?? null,
-        data.provider ?? null,
-        data.altTitle ?? null,
-        data.contentRating ?? null,
-    ]),
-    deleteByManga: (db, mangaId) => dbRun(db, 'DELETE FROM manga_progress WHERE mangaId = ?', [mangaId]),
+    getByManga: (db, mangaId) => getDrizzle(db).all(sql `
+      SELECT mangaId, chapterId, chapterNumber, page, pageCount, updatedAt FROM manga_progress WHERE mangaId = ${mangaId} ORDER BY updatedAt DESC`),
+    getChapter: async (db, mangaId, chapterId) => {
+        const rows = await getDrizzle(db).all(sql `
+      SELECT mangaId, chapterId, chapterNumber, page, pageCount, updatedAt FROM manga_progress WHERE mangaId = ${mangaId} AND chapterId = ${chapterId}`);
+        return rows[0];
+    },
+    getLatest: async (db, mangaId) => {
+        const rows = await getDrizzle(db).all(sql `
+      SELECT mangaId, chapterId, chapterNumber, page, pageCount, updatedAt FROM manga_progress WHERE mangaId = ${mangaId} ORDER BY updatedAt DESC LIMIT 1`);
+        return rows[0];
+    },
+    upsert: (db, data) => getDrizzle(db).run(sql `
+      INSERT INTO manga_progress (mangaId, chapterId, chapterNumber, page, pageCount, title, cover, provider, altTitle, contentRating, updatedAt)
+      VALUES (${data.mangaId}, ${data.chapterId}, ${data.chapterNumber}, ${data.page}, ${data.pageCount}, ${data.title ?? null}, ${data.cover ?? null}, ${data.provider ?? null}, ${data.altTitle ?? null}, ${data.contentRating ?? null}, strftime('%s', 'now'))
+      ON CONFLICT(mangaId, chapterId) DO UPDATE SET
+         chapterNumber = COALESCE(NULLIF(EXCLUDED.chapterNumber, ''), manga_progress.chapterNumber),
+         page = EXCLUDED.page,
+         pageCount = EXCLUDED.pageCount,
+         title = COALESCE(EXCLUDED.title, manga_progress.title),
+         cover = COALESCE(EXCLUDED.cover, manga_progress.cover),
+         provider = COALESCE(EXCLUDED.provider, manga_progress.provider),
+         altTitle = COALESCE(EXCLUDED.altTitle, manga_progress.altTitle),
+         contentRating = COALESCE(EXCLUDED.contentRating, manga_progress.contentRating),
+         updatedAt = strftime('%s', 'now')`),
+    deleteByManga: (db, mangaId) => getDrizzle(db).delete(mangaProgress).where(eq(mangaProgress.mangaId, mangaId)),
     deleteMany: (db, ids) => {
         if (ids.length === 0)
-            return;
-        const placeholders = ids.map(() => '?').join(', ');
-        dbRun(db, `DELETE FROM manga_progress WHERE mangaId IN (${placeholders})`, ids);
+            return Promise.resolve();
+        return getDrizzle(db).delete(mangaProgress).where(inArray(mangaProgress.mangaId, ids));
     },
-    deleteChapter: (db, mangaId, chapterId) => dbRun(db, 'DELETE FROM manga_progress WHERE mangaId = ? AND chapterId = ?', [
-        mangaId,
-        chapterId,
-    ]),
-    deleteSyntheticChapters: (db, mangaId, keepChapterId) => dbRun(db, `DELETE FROM manga_progress WHERE mangaId = ? AND chapterId LIKE 'anilist:ch:%' AND chapterId != ?`, [mangaId, keepChapterId]),
-    moveSyntheticChapters: (db, fromMangaId, toMangaId) => dbRun(db, `UPDATE manga_progress SET mangaId = ?, updatedAt = strftime('%s', 'now') WHERE mangaId = ? AND chapterId LIKE 'anilist:ch:%'`, [toMangaId, fromMangaId]),
+    deleteChapter: (db, mangaId, chapterId) => getDrizzle(db).run(sql `
+      DELETE FROM manga_progress WHERE mangaId = ${mangaId} AND chapterId = ${chapterId}`),
+    deleteSyntheticChapters: (db, mangaId, keepChapterId) => getDrizzle(db).run(sql `
+      DELETE FROM manga_progress WHERE mangaId = ${mangaId} AND chapterId LIKE 'anilist:ch:%' AND chapterId != ${keepChapterId}`),
+    moveSyntheticChapters: (db, fromMangaId, toMangaId) => getDrizzle(db).run(sql `
+      UPDATE manga_progress SET mangaId = ${toMangaId}, updatedAt = strftime('%s', 'now') WHERE mangaId = ${fromMangaId} AND chapterId LIKE 'anilist:ch:%'`),
     getContinueReading: (db, limit) => {
         const limitClause = typeof limit === 'number' ? `LIMIT ${limit}` : '';
-        return dbAll(db, `SELECT p.mangaId as id,
-              COALESCE(l.mangaId, SUBSTR(p.mangaId, INSTR(p.mangaId, ':') + 1)) as mangaId,
-              COALESCE(l.provider, p.provider) as provider,
-              COALESCE(l.title, p.title) as title, COALESCE(l.cover, p.cover) as cover,
-              COALESCE(l.author, '') as author, COALESCE(l.altTitle, p.altTitle) as altTitle,
-              COALESCE(l.contentRating, p.contentRating) as contentRating,
-              l.status as watchlistStatus,
-              p.chapterId, p.chapterNumber, p.page, p.pageCount, p.updatedAt as progressAt
-       FROM (
-         SELECT *, ROW_NUMBER() OVER (PARTITION BY mangaId ORDER BY updatedAt DESC) as rn
-         FROM manga_progress
-       ) p
-       LEFT JOIN manga_library l ON p.mangaId = l.id
-       WHERE p.rn = 1
-         AND (l.status IS NULL OR l.status = 'Reading')
-       ORDER BY p.updatedAt DESC
-       ${limitClause}`);
+        return getDrizzle(db).all(sql `
+      SELECT p.mangaId as id,
+             COALESCE(l.mangaId, SUBSTR(p.mangaId, INSTR(p.mangaId, ':') + 1)) as mangaId,
+             COALESCE(l.provider, p.provider) as provider,
+             COALESCE(l.title, p.title) as title, COALESCE(l.cover, p.cover) as cover,
+             COALESCE(l.author, '') as author, COALESCE(l.altTitle, p.altTitle) as altTitle,
+             COALESCE(l.contentRating, p.contentRating) as contentRating,
+             l.status as watchlistStatus,
+             p.chapterId, p.chapterNumber, p.page, p.pageCount, p.updatedAt as progressAt
+      FROM (
+        SELECT *, ROW_NUMBER() OVER (PARTITION BY mangaId ORDER BY updatedAt DESC) as rn
+        FROM manga_progress
+      ) p
+      LEFT JOIN manga_library l ON p.mangaId = l.id
+      WHERE p.rn = 1
+        AND (l.status IS NULL OR l.status = 'Reading')
+      ORDER BY p.updatedAt DESC
+      ${sql.raw(limitClause)}`);
     },
 };

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

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

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

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

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

@@ -1,12 +1,22 @@
-import { dbGet, dbRun } from '../utils/db-utils.js';
+import { eq, sql } from 'drizzle-orm';
+import { getDrizzle } from '../db/drizzle.js';
+import { settings, watchlist } from '../db/schema-anime.js';
 export const SettingsRepository = {
-    getByKey: (db, key) => dbGet(db, 'SELECT value FROM settings WHERE key = ?', [key]),
-    upsert: (db, key, value) => dbRun(db, 'INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)', [key, value]),
-    deleteByKey: (db, key) => dbRun(db, 'DELETE FROM settings WHERE key = ?', [key]),
-    clearWatchlist: (db) => dbRun(db, 'DELETE FROM watchlist'),
+    getByKey: async (db, key) => {
+        const rows = await getDrizzle(db).all(sql `SELECT value FROM settings WHERE key = ${key}`);
+        return rows[0];
+    },
+    upsert: (db, key, value) => getDrizzle(db)
+        .insert(settings)
+        .values({ key, value })
+        .onConflictDoUpdate({ target: settings.key, set: { value } }),
+    deleteByKey: (db, key) => getDrizzle(db).delete(settings).where(eq(settings.key, key)),
+    clearWatchlist: (db) => getDrizzle(db).delete(watchlist),
     upsertWatchlistBatch: (db, shows) => {
-        for (const show of shows) {
-            dbRun(db, 'INSERT OR REPLACE INTO watchlist (id, name, thumbnail, status) VALUES (?, ?, ?, ?)', [show.id, show.name, show.thumbnail ?? null, show.status]);
-        }
+        if (shows.length === 0)
+            return Promise.resolve();
+        return getDrizzle(db).run(sql `
+      INSERT OR REPLACE INTO watchlist (id, name, thumbnail, status) VALUES
+      ${sql.join(shows.map((s) => sql `(${s.id}, ${s.name}, ${s.thumbnail ?? null}, ${s.status})`), sql `, `)}`);
     },
 };

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

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