@serifpersia/dango 3.3.8 → 3.4.0

package/server/dist/repositories/temp-show-ids.repository.js

@@ -1,51 +1,63 @@
-import { dbGet, dbRun } from '../utils/db-utils.js';
+import { sql } from 'drizzle-orm';
+import { getDrizzle } from '../db/drizzle.js';
+import { tempShowIds } from '../db/schema-anime.js';
 import { TEMP_SHOW_ID_PREFIX } from '../lib/temp-ids.js';
 export const TempShowIdsRepository = {
-    getById: (db, id) => dbGet(db, 'SELECT * FROM temp_show_ids WHERE id = ?', [id]),
-    getByProviderNative: (db, provider, nativeId) => dbGet(db, 'SELECT * FROM temp_show_ids WHERE provider = ? AND nativeId = ?', [
-        provider,
-        nativeId,
-    ]),
-    count: (db) => {
-        const row = dbGet(db, 'SELECT COUNT(*) as total FROM temp_show_ids');
-        return row?.total || 0;
+    getById: async (db, id) => {
+        const rows = await getDrizzle(db).all(sql `SELECT * FROM temp_show_ids WHERE id = ${id}`);
+        return rows[0];
     },
-    allocate: (db, data) => {
-        const existing = TempShowIdsRepository.getByProviderNative(db, data.provider, data.nativeId);
+    getByProviderNative: async (db, provider, nativeId) => {
+        const rows = await getDrizzle(db).all(sql `SELECT * FROM temp_show_ids WHERE provider = ${provider} AND nativeId = ${nativeId}`);
+        return rows[0];
+    },
+    count: async (db) => {
+        const rows = await getDrizzle(db).all(sql `SELECT COUNT(*) as total FROM temp_show_ids`);
+        return rows[0]?.total || 0;
+    },
+    allocate: async (db, data) => {
+        const existing = await TempShowIdsRepository.getByProviderNative(db, data.provider, data.nativeId);
         if (existing)
             return existing;
         const prefixLen = TEMP_SHOW_ID_PREFIX.length + 1;
-        const maxRow = dbGet(db, `SELECT MAX(CAST(SUBSTR(id, ?) AS INTEGER)) as maxId FROM temp_show_ids WHERE id LIKE '${TEMP_SHOW_ID_PREFIX}%'`, [prefixLen]);
-        const next = (maxRow?.maxId || 0) + 1;
+        const maxRows = await getDrizzle(db).all(sql `
+      SELECT MAX(CAST(SUBSTR(id, ${prefixLen}) AS INTEGER)) as maxId FROM temp_show_ids WHERE id LIKE ${`${TEMP_SHOW_ID_PREFIX}%`}`);
+        const next = (maxRows[0]?.maxId || 0) + 1;
         const id = `${TEMP_SHOW_ID_PREFIX}${next}`;
         try {
-            dbRun(db, 'INSERT INTO temp_show_ids (id, provider, nativeId, title, thumbnail, createdAt) VALUES (?, ?, ?, ?, ?, ?)', [id, data.provider, data.nativeId, data.title, data.thumbnail || '', Date.now()]);
+            await getDrizzle(db)
+                .insert(tempShowIds)
+                .values({
+                id,
+                provider: data.provider,
+                nativeId: data.nativeId,
+                title: data.title,
+                thumbnail: data.thumbnail || '',
+                createdAt: Date.now(),
+            });
         }
         catch {
-            // Lost a race with a concurrent allocate — return whatever won.
-            const winner = TempShowIdsRepository.getByProviderNative(db, data.provider, data.nativeId);
+            const winner = await TempShowIdsRepository.getByProviderNative(db, data.provider, data.nativeId);
             if (winner)
                 return winner;
             throw new Error('temp id allocation failed');
         }
-        return TempShowIdsRepository.getById(db, id);
+        return (await TempShowIdsRepository.getById(db, id));
     },
-    purge: (db) => {
-        const total = TempShowIdsRepository.count(db);
+    purge: async (db) => {
+        const total = await TempShowIdsRepository.count(db);
         if (total === 0)
             return 0;
-        const like = `${TEMP_SHOW_ID_PREFIX}%`;
-        dbRun(db, 'DELETE FROM watchlist WHERE id LIKE ?', [like]);
-        dbRun(db, 'DELETE FROM watched_episodes WHERE showId LIKE ?', [like]);
-        dbRun(db, 'DELETE FROM queue WHERE showId LIKE ?', [like]);
-        dbRun(db, 'DELETE FROM shows_meta WHERE id LIKE ?', [like]);
-        dbRun(db, 'DELETE FROM dismissed_notifications WHERE showId LIKE ?', [like]);
-        dbRun(db, 'DELETE FROM discovered_notifications WHERE showId LIKE ?', [like]);
-        dbRun(db, 'DELETE FROM legacy_id_mapping WHERE legacyId LIKE ? OR numericId LIKE ?', [
-            like,
-            like,
-        ]);
-        dbRun(db, 'DELETE FROM temp_show_ids');
+        const likePattern = `${TEMP_SHOW_ID_PREFIX}%`;
+        await getDrizzle(db).run(sql `DELETE FROM watchlist WHERE id LIKE ${likePattern}`);
+        await getDrizzle(db).run(sql `DELETE FROM watched_episodes WHERE showId LIKE ${likePattern}`);
+        await getDrizzle(db).run(sql `DELETE FROM queue WHERE showId LIKE ${likePattern}`);
+        await getDrizzle(db).run(sql `DELETE FROM shows_meta WHERE id LIKE ${likePattern}`);
+        await getDrizzle(db).run(sql `DELETE FROM dismissed_notifications WHERE showId LIKE ${likePattern}`);
+        await getDrizzle(db).run(sql `DELETE FROM discovered_notifications WHERE showId LIKE ${likePattern}`);
+        await getDrizzle(db).run(sql `
+      DELETE FROM legacy_id_mapping WHERE legacyId LIKE ${likePattern} OR numericId LIKE ${likePattern}`);
+        await getDrizzle(db).delete(tempShowIds);
         return total;
     },
 };

package/server/dist/repositories/tv.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 { tvLibrary, tvProgress } from '../db/schema-tv.js';
 export const TV_STATUSES = ['Watching', 'Completed', 'On-Hold', 'Dropped', 'Planned'];
 export function buildTvId(mediaType, tmdbId) {
     const t = String(mediaType).toLowerCase() === 'movie' ? 'movie' : 'tv';
@@ -12,142 +14,123 @@ export function normalizeTvMediaId(raw) {
     return s;
 }
 export const TvLibraryRepository = {
-    getById: (db, id) => dbGet(db, 'SELECT * FROM tv_library WHERE id = ?', [id]),
-    exists: (db, id) => {
-        const row = dbGet(db, 'SELECT EXISTS(SELECT 1 FROM tv_library WHERE id = ?) as inLibrary', [id]);
-        return !!(row && row.inLibrary);
+    getById: async (db, id) => {
+        const rows = await getDrizzle(db).all(sql `SELECT * FROM tv_library WHERE id = ${id}`);
+        return rows[0];
+    },
+    exists: async (db, id) => {
+        const rows = await getDrizzle(db).all(sql `SELECT EXISTS(SELECT 1 FROM tv_library WHERE id = ${id}) as inLibrary`);
+        return !!(rows[0] && rows[0].inLibrary);
     },
     getAll: (db, status, limit, offset) => {
-        let query = 'SELECT * FROM tv_library';
-        const params = [];
+        const q = sql `SELECT * FROM tv_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 tv_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 tv_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 tv_library`);
+        return rows[0]?.total || 0;
+    },
+    getIds: async (db) => {
+        const rows = await getDrizzle(db).all(sql `SELECT id FROM tv_library`);
+        return rows.map((r) => r.id);
     },
-    getIds: (db) => dbAll(db, 'SELECT id FROM tv_library').map((r) => r.id),
-    upsert: (db, data) => dbRun(db, `INSERT INTO tv_library (id, tmdbId, mediaType, title, poster, backdrop, year, overview, status, adult, updatedAt)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, strftime('%s', 'now'))
-       ON CONFLICT(id) DO UPDATE SET
-          tmdbId = EXCLUDED.tmdbId,
-          mediaType = EXCLUDED.mediaType,
-          title = COALESCE(NULLIF(EXCLUDED.title, ''), tv_library.title),
-          poster = COALESCE(NULLIF(EXCLUDED.poster, ''), tv_library.poster),
-          backdrop = COALESCE(NULLIF(EXCLUDED.backdrop, ''), tv_library.backdrop),
-          year = COALESCE(NULLIF(EXCLUDED.year, ''), tv_library.year),
-          overview = COALESCE(NULLIF(EXCLUDED.overview, ''), tv_library.overview),
-          status = COALESCE(NULLIF(EXCLUDED.status, ''), tv_library.status),
-          adult = COALESCE(EXCLUDED.adult, tv_library.adult),
-          updatedAt = strftime('%s', 'now')`, [
-        data.id,
-        data.tmdbId,
-        data.mediaType,
-        data.title,
-        data.poster,
-        data.backdrop || null,
-        data.year || null,
-        data.overview || null,
-        data.status,
-        data.adult ? 1 : 0,
-    ]),
-    updateStatus: (db, id, status) => dbRun(db, "UPDATE tv_library SET status = ?, updatedAt = strftime('%s', 'now') WHERE id = ?", [
-        status,
-        id,
-    ]),
+    upsert: (db, data) => getDrizzle(db).run(sql `
+      INSERT INTO tv_library (id, tmdbId, mediaType, title, poster, backdrop, year, overview, status, adult, updatedAt)
+      VALUES (${data.id}, ${data.tmdbId}, ${data.mediaType}, ${data.title}, ${data.poster}, ${data.backdrop || null}, ${data.year || null}, ${data.overview || null}, ${data.status}, ${data.adult ? 1 : 0}, strftime('%s', 'now'))
+      ON CONFLICT(id) DO UPDATE SET
+         tmdbId = EXCLUDED.tmdbId,
+         mediaType = EXCLUDED.mediaType,
+         title = COALESCE(NULLIF(EXCLUDED.title, ''), tv_library.title),
+         poster = COALESCE(NULLIF(EXCLUDED.poster, ''), tv_library.poster),
+         backdrop = COALESCE(NULLIF(EXCLUDED.backdrop, ''), tv_library.backdrop),
+         year = COALESCE(NULLIF(EXCLUDED.year, ''), tv_library.year),
+         overview = COALESCE(NULLIF(EXCLUDED.overview, ''), tv_library.overview),
+         status = COALESCE(NULLIF(EXCLUDED.status, ''), tv_library.status),
+         adult = COALESCE(EXCLUDED.adult, tv_library.adult),
+         updatedAt = strftime('%s', 'now')`),
+    updateStatus: (db, id, status) => getDrizzle(db).run(sql `
+      UPDATE tv_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 tv_library SET status = ?, updatedAt = strftime('%s', 'now') WHERE id IN (${placeholders})`, [status, ...ids]);
+            return Promise.resolve();
+        return getDrizzle(db).run(sql `
+      UPDATE tv_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 tv_library SET lastSeason = ?, lastEpisode = ?, updatedAt = strftime('%s', 'now') WHERE id = ?`, [progress.season, progress.episode, id]),
-    delete: (db, id) => dbRun(db, 'DELETE FROM tv_library WHERE id = ?', [id]),
+    touchProgress: (db, id, progress) => getDrizzle(db).run(sql `
+      UPDATE tv_library SET lastSeason = ${progress.season}, lastEpisode = ${progress.episode}, updatedAt = strftime('%s', 'now') WHERE id = ${id}`),
+    delete: (db, id) => getDrizzle(db).delete(tvLibrary).where(eq(tvLibrary.id, id)),
     deleteMany: (db, ids) => {
         if (ids.length === 0)
-            return;
-        const placeholders = ids.map(() => '?').join(', ');
-        dbRun(db, `DELETE FROM tv_library WHERE id IN (${placeholders})`, ids);
+            return Promise.resolve();
+        return getDrizzle(db).delete(tvLibrary).where(inArray(tvLibrary.id, ids));
     },
 };
 export const TvProgressRepository = {
-    getByMedia: (db, mediaId) => dbAll(db, 'SELECT mediaId, season, episode, currentTime, duration, completed, updatedAt FROM tv_progress WHERE mediaId = ? ORDER BY updatedAt DESC, rowid DESC', [mediaId]),
-    getEpisode: (db, mediaId, season, episode) => dbGet(db, 'SELECT mediaId, season, episode, currentTime, duration, completed, updatedAt FROM tv_progress WHERE mediaId = ? AND season = ? AND episode = ?', [mediaId, season, episode]),
-    getLatest: (db, mediaId) => dbGet(db, 'SELECT mediaId, season, episode, currentTime, duration, completed, updatedAt FROM tv_progress WHERE mediaId = ? ORDER BY updatedAt DESC, rowid DESC LIMIT 1', [mediaId]),
-    upsert: (db, data) => dbRun(db, `INSERT INTO tv_progress (mediaId, season, episode, currentTime, duration, completed, title, poster, backdrop, year, overview, tmdbId, mediaType, adult, updatedAt)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, strftime('%s', 'now'))
-       ON CONFLICT(mediaId, season, episode) DO UPDATE SET
-          currentTime = EXCLUDED.currentTime,
-          duration = EXCLUDED.duration,
-          completed = CASE WHEN tv_progress.completed = 1 OR EXCLUDED.completed = 1 THEN 1 ELSE 0 END,
-          title = COALESCE(EXCLUDED.title, tv_progress.title),
-          poster = COALESCE(EXCLUDED.poster, tv_progress.poster),
-          backdrop = COALESCE(EXCLUDED.backdrop, tv_progress.backdrop),
-          year = COALESCE(EXCLUDED.year, tv_progress.year),
-          overview = COALESCE(EXCLUDED.overview, tv_progress.overview),
-          tmdbId = COALESCE(EXCLUDED.tmdbId, tv_progress.tmdbId),
-          mediaType = COALESCE(EXCLUDED.mediaType, tv_progress.mediaType),
-          adult = COALESCE(EXCLUDED.adult, tv_progress.adult),
-          updatedAt = strftime('%s', 'now')`, [
-        data.mediaId,
-        data.season,
-        data.episode,
-        data.currentTime,
-        data.duration,
-        data.completed,
-        data.title ?? null,
-        data.poster ?? null,
-        data.backdrop ?? null,
-        data.year ?? null,
-        data.overview ?? null,
-        data.tmdbId ?? null,
-        data.mediaType ?? null,
-        data.adult ?? null,
-    ]),
-    deleteByMedia: (db, mediaId) => dbRun(db, 'DELETE FROM tv_progress WHERE mediaId = ?', [mediaId]),
+    getByMedia: (db, mediaId) => getDrizzle(db).all(sql `
+      SELECT mediaId, season, episode, currentTime, duration, completed, updatedAt FROM tv_progress WHERE mediaId = ${mediaId} ORDER BY updatedAt DESC, rowid DESC`),
+    getEpisode: async (db, mediaId, season, episode) => {
+        const rows = await getDrizzle(db).all(sql `
+      SELECT mediaId, season, episode, currentTime, duration, completed, updatedAt FROM tv_progress WHERE mediaId = ${mediaId} AND season = ${season} AND episode = ${episode}`);
+        return rows[0];
+    },
+    getLatest: async (db, mediaId) => {
+        const rows = await getDrizzle(db).all(sql `
+      SELECT mediaId, season, episode, currentTime, duration, completed, updatedAt FROM tv_progress WHERE mediaId = ${mediaId} ORDER BY updatedAt DESC, rowid DESC LIMIT 1`);
+        return rows[0];
+    },
+    upsert: (db, data) => getDrizzle(db).run(sql `
+      INSERT INTO tv_progress (mediaId, season, episode, currentTime, duration, completed, title, poster, backdrop, year, overview, tmdbId, mediaType, adult, updatedAt)
+      VALUES (${data.mediaId}, ${data.season}, ${data.episode}, ${data.currentTime}, ${data.duration}, ${data.completed}, ${data.title ?? null}, ${data.poster ?? null}, ${data.backdrop ?? null}, ${data.year ?? null}, ${data.overview ?? null}, ${data.tmdbId ?? null}, ${data.mediaType ?? null}, ${data.adult ?? null}, strftime('%s', 'now'))
+      ON CONFLICT(mediaId, season, episode) DO UPDATE SET
+         currentTime = EXCLUDED.currentTime,
+         duration = EXCLUDED.duration,
+         completed = EXCLUDED.completed,
+         title = COALESCE(EXCLUDED.title, tv_progress.title),
+         poster = COALESCE(EXCLUDED.poster, tv_progress.poster),
+         backdrop = COALESCE(EXCLUDED.backdrop, tv_progress.backdrop),
+         year = COALESCE(EXCLUDED.year, tv_progress.year),
+         overview = COALESCE(EXCLUDED.overview, tv_progress.overview),
+         tmdbId = COALESCE(EXCLUDED.tmdbId, tv_progress.tmdbId),
+         mediaType = COALESCE(EXCLUDED.mediaType, tv_progress.mediaType),
+         adult = COALESCE(EXCLUDED.adult, tv_progress.adult),
+         updatedAt = strftime('%s', 'now')`),
+    deleteByMedia: (db, mediaId) => getDrizzle(db).delete(tvProgress).where(eq(tvProgress.mediaId, mediaId)),
     deleteMany: (db, ids) => {
         if (ids.length === 0)
-            return;
-        const placeholders = ids.map(() => '?').join(', ');
-        dbRun(db, `DELETE FROM tv_progress WHERE mediaId IN (${placeholders})`, ids);
+            return Promise.resolve();
+        return getDrizzle(db).delete(tvProgress).where(inArray(tvProgress.mediaId, ids));
     },
-    deleteEpisode: (db, mediaId, season, episode) => dbRun(db, 'DELETE FROM tv_progress WHERE mediaId = ? AND season = ? AND episode = ?', [
-        mediaId,
-        season,
-        episode,
-    ]),
+    deleteEpisode: (db, mediaId, season, episode) => getDrizzle(db).run(sql `
+      DELETE FROM tv_progress WHERE mediaId = ${mediaId} AND season = ${season} AND episode = ${episode}`),
     getContinueWatching: (db, limit) => {
         const limitClause = typeof limit === 'number' ? `LIMIT ${limit}` : '';
-        return dbAll(db, `SELECT p.mediaId as id,
-              COALESCE(l.tmdbId, p.tmdbId, CAST(SUBSTR(REPLACE(p.mediaId, '-', ':'), INSTR(REPLACE(p.mediaId, '-', ':'), ':') + 1) AS INTEGER)) as tmdbId,
-              COALESCE(l.mediaType, p.mediaType, SUBSTR(REPLACE(p.mediaId, '-', ':'), 1, INSTR(REPLACE(p.mediaId, '-', ':'), ':') - 1)) as mediaType,
-              COALESCE(l.title, p.title) as title, COALESCE(l.poster, p.poster) as poster, COALESCE(l.backdrop, p.backdrop) as backdrop,
-              COALESCE(l.year, p.year) as year, COALESCE(l.overview, p.overview) as overview,
-              l.status as watchlistStatus, COALESCE(l.adult, p.adult) as adult,
-              p.season, p.episode, p.currentTime, p.duration, p.completed, p.updatedAt as progressAt
-       FROM (
-         SELECT *, rowid AS progressRowid, ROW_NUMBER() OVER (PARTITION BY mediaId ORDER BY updatedAt DESC, rowid DESC) as rn
-         FROM tv_progress
-       ) p
-       LEFT JOIN tv_library l ON p.mediaId = l.id
-       WHERE p.rn = 1
-         AND (l.status IS NULL OR l.status = 'Watching')
-       ORDER BY p.updatedAt DESC, p.progressRowid DESC
-       ${limitClause}`);
+        return getDrizzle(db).all(sql `
+      SELECT p.mediaId as id,
+             COALESCE(l.tmdbId, p.tmdbId, CAST(SUBSTR(REPLACE(p.mediaId, '-', ':'), INSTR(REPLACE(p.mediaId, '-', ':'), ':') + 1) AS INTEGER)) as tmdbId,
+             COALESCE(l.mediaType, p.mediaType, SUBSTR(REPLACE(p.mediaId, '-', ':'), 1, INSTR(REPLACE(p.mediaId, '-', ':'), ':') - 1)) as mediaType,
+             COALESCE(l.title, p.title) as title, COALESCE(l.poster, p.poster) as poster, COALESCE(l.backdrop, p.backdrop) as backdrop,
+             COALESCE(l.year, p.year) as year, COALESCE(l.overview, p.overview) as overview,
+             l.status as watchlistStatus, COALESCE(l.adult, p.adult) as adult,
+             p.season, p.episode, p.currentTime, p.duration, p.completed, p.updatedAt as progressAt
+      FROM (
+        SELECT *, rowid AS progressRowid, ROW_NUMBER() OVER (PARTITION BY mediaId ORDER BY updatedAt DESC, rowid DESC) as rn
+        FROM tv_progress
+      ) p
+      LEFT JOIN tv_library l ON p.mediaId = l.id
+      WHERE p.rn = 1
+        AND (l.status IS NULL OR l.status = 'Watching')
+      ORDER BY p.updatedAt DESC, p.progressRowid DESC
+      ${sql.raw(limitClause)}`);
     },
 };

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

@@ -1,22 +1,58 @@
-import { dbAll, dbGet, dbRun } from '../utils/db-utils.js';
+import { eq, sql } from 'drizzle-orm';
+import { getDrizzle } from '../db/drizzle.js';
+import { watchedEpisodes } from '../db/schema-anime.js';
 export const WatchedEpisodesRepository = {
-    getByShowAndEpisode: (db, showId, episodeNumber) => dbGet(db, 'SELECT currentTime, duration FROM watched_episodes WHERE showId = ? AND episodeNumber = ?', [showId, episodeNumber]),
+    getByShowAndEpisode: async (db, showId, episodeNumber) => {
+        const rows = await getDrizzle(db).all(sql `
+      SELECT currentTime, duration FROM watched_episodes WHERE showId = ${showId} AND episodeNumber = ${episodeNumber}`);
+        return rows[0];
+    },
     getWatchedEpisodeNumbers: async (db, showId) => {
-        const rows = await dbAll(db, 'SELECT episodeNumber FROM watched_episodes WHERE showId = ?', [showId]);
+        const rows = await getDrizzle(db).all(sql `SELECT episodeNumber FROM watched_episodes WHERE showId = ${showId}`);
         return rows.map((r) => r.episodeNumber);
     },
-    getByShow: (db, showId) => dbAll(db, 'SELECT showId, episodeNumber, currentTime, duration, watchedAt FROM watched_episodes WHERE showId = ? ORDER BY CAST(episodeNumber AS REAL) ASC', [showId]),
-    getLatestResumeProgress: (db, showId) => dbGet(db, `SELECT showId, episodeNumber, currentTime, duration, watchedAt
-       FROM watched_episodes
-       WHERE showId = ? AND currentTime > 5 AND (duration <= 0 OR currentTime < duration * 0.8)
-       ORDER BY watchedAt DESC
-       LIMIT 1`, [showId]),
-    upsert: (db, data) => dbRun(db, 'INSERT OR REPLACE INTO watched_episodes (showId, episodeNumber, watchedAt, currentTime, duration) VALUES (?, ?, CURRENT_TIMESTAMP, ?, ?)', [data.showId, data.episodeNumber, data.currentTime, data.duration]),
-    insertIfMissing: (db, data) => dbRun(db, 'INSERT OR IGNORE INTO watched_episodes (showId, episodeNumber, watchedAt, currentTime, duration) VALUES (?, ?, COALESCE(?, CURRENT_TIMESTAMP), 0, 0)', [data.showId, data.episodeNumber, data.watchedAt ?? null]),
-    deleteByShow: (db, showId) => dbRun(db, 'DELETE FROM watched_episodes WHERE showId = ?', [showId]),
+    getByShow: (db, showId) => getDrizzle(db).all(sql `
+      SELECT showId, episodeNumber, currentTime, duration, watchedAt FROM watched_episodes WHERE showId = ${showId} ORDER BY CAST(episodeNumber AS REAL) ASC`),
+    getLatestResumeProgress: async (db, showId) => {
+        const rows = await getDrizzle(db).all(sql `
+      SELECT showId, episodeNumber, currentTime, duration, watchedAt
+      FROM watched_episodes
+      WHERE showId = ${showId} AND currentTime > 5 AND (duration <= 0 OR currentTime < duration * 0.8)
+      ORDER BY watchedAt DESC
+      LIMIT 1`);
+        return rows[0];
+    },
+    upsert: (db, data) => getDrizzle(db)
+        .insert(watchedEpisodes)
+        .values({
+        showId: data.showId,
+        episodeNumber: data.episodeNumber,
+        watchedAt: sql `CURRENT_TIMESTAMP`,
+        currentTime: data.currentTime,
+        duration: data.duration,
+    })
+        .onConflictDoUpdate({
+        target: [watchedEpisodes.showId, watchedEpisodes.episodeNumber],
+        set: {
+            watchedAt: sql `CURRENT_TIMESTAMP`,
+            currentTime: data.currentTime,
+            duration: data.duration,
+        },
+    }),
+    insertIfMissing: (db, data) => getDrizzle(db)
+        .insert(watchedEpisodes)
+        .values({
+        showId: data.showId,
+        episodeNumber: data.episodeNumber,
+        watchedAt: data.watchedAt ? sql `${data.watchedAt}` : sql `CURRENT_TIMESTAMP`,
+        currentTime: 0,
+        duration: 0,
+    })
+        .onConflictDoNothing(),
+    deleteByShow: (db, showId) => getDrizzle(db).delete(watchedEpisodes).where(eq(watchedEpisodes.showId, showId)),
     getContinueWatching: (db, limit) => {
         const limitClause = typeof limit === 'number' ? `LIMIT ${limit}` : '';
-        const query = `
+        return getDrizzle(db).all(sql `
       SELECT
         we.showId as _id,
         we.showId as id,
@@ -41,12 +77,8 @@ export const WatchedEpisodesRepository = {
         AND (w.status IS NULL OR w.status = 'Watching')
         AND (w.id IS NOT NULL OR sm.id IS NOT NULL)
       ORDER BY we.watchedAt DESC
-      ${limitClause}
-    `;
-        return dbAll(db, query);
-    },
-    getEpisodesForShows: (db, showIds) => {
-        const placeholders = showIds.map(() => '?').join(',');
-        return dbAll(db, `SELECT showId, episodeNumber, currentTime, duration, watchedAt FROM watched_episodes WHERE showId IN (${placeholders})`, showIds);
+      ${sql.raw(limitClause)}`);
     },
+    getEpisodesForShows: (db, showIds) => getDrizzle(db).all(sql `
+      SELECT showId, episodeNumber, currentTime, duration, watchedAt FROM watched_episodes WHERE showId IN (${sql.join(showIds.map((id) => sql `${id}`), sql `, `)})`),
 };

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

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