@serifpersia/dango 3.3.9 → 3.4.1

package/server/dist/repositories/asmr.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 { asmrLibrary, asmrProgress } from '../db/schema-asmr.js';
 export const ASMR_STATUSES = [
     'Listening',
     'Completed',
@@ -10,114 +12,115 @@ export function buildAsmrId(rjCode) {
     return String(rjCode).trim().toUpperCase();
 }
 export const AsmrLibraryRepository = {
-    getById: (db, id) => dbGet(db, 'SELECT * FROM asmr_library WHERE id = ?', [id]),
-    exists: (db, id) => {
-        const row = dbGet(db, 'SELECT EXISTS(SELECT 1 FROM asmr_library WHERE id = ?) as inLibrary', [id]);
-        return !!(row && row.inLibrary);
+    getById: async (db, id) => {
+        const rows = await getDrizzle(db).all(sql `SELECT * FROM asmr_library WHERE id = ${id}`);
+        return rows[0];
+    },
+    exists: async (db, id) => {
+        const rows = await getDrizzle(db).all(sql `SELECT EXISTS(SELECT 1 FROM asmr_library WHERE id = ${id}) as inLibrary`);
+        return !!(rows[0] && rows[0].inLibrary);
     },
     getAll: (db, status, limit, offset) => {
-        let query = 'SELECT * FROM asmr_library';
-        const params = [];
+        const q = sql `SELECT * FROM asmr_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 asmr_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 asmr_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 asmr_library`);
+        return rows[0]?.total || 0;
+    },
+    getIds: async (db) => {
+        const rows = await getDrizzle(db).all(sql `SELECT id FROM asmr_library`);
+        return rows.map((r) => r.id);
     },
-    getIds: (db) => dbAll(db, 'SELECT id FROM asmr_library').map((r) => r.id),
-    upsert: (db, data) => dbRun(db, `INSERT INTO asmr_library (id, rjCode, title, thumbnail, status, isAdult, updatedAt)
-       VALUES (?, ?, ?, ?, ?, ?, strftime('%s', 'now'))
-       ON CONFLICT(id) DO UPDATE SET
-          rjCode = COALESCE(NULLIF(EXCLUDED.rjCode, ''), asmr_library.rjCode),
-          title = COALESCE(NULLIF(EXCLUDED.title, ''), asmr_library.title),
-          thumbnail = COALESCE(NULLIF(EXCLUDED.thumbnail, ''), asmr_library.thumbnail),
-          status = COALESCE(NULLIF(EXCLUDED.status, ''), asmr_library.status),
-          isAdult = COALESCE(EXCLUDED.isAdult, asmr_library.isAdult),
-          updatedAt = strftime('%s', 'now')`, [data.id, data.rjCode, data.title, data.thumbnail, data.status, data.isAdult ? 1 : 0]),
-    updateStatus: (db, id, status) => dbRun(db, "UPDATE asmr_library SET status = ?, updatedAt = strftime('%s', 'now') WHERE id = ?", [status, id]),
+    upsert: (db, data) => getDrizzle(db).run(sql `
+      INSERT INTO asmr_library (id, rjCode, title, thumbnail, status, isAdult, updatedAt)
+      VALUES (${data.id}, ${data.rjCode}, ${data.title}, ${data.thumbnail}, ${data.status}, ${data.isAdult ? 1 : 0}, strftime('%s', 'now'))
+      ON CONFLICT(id) DO UPDATE SET
+         rjCode = COALESCE(NULLIF(EXCLUDED.rjCode, ''), asmr_library.rjCode),
+         title = COALESCE(NULLIF(EXCLUDED.title, ''), asmr_library.title),
+         thumbnail = COALESCE(NULLIF(EXCLUDED.thumbnail, ''), asmr_library.thumbnail),
+         status = COALESCE(NULLIF(EXCLUDED.status, ''), asmr_library.status),
+         isAdult = COALESCE(EXCLUDED.isAdult, asmr_library.isAdult),
+         updatedAt = strftime('%s', 'now')`),
+    updateStatus: (db, id, status) => getDrizzle(db).run(sql `
+      UPDATE asmr_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 asmr_library SET status = ?, updatedAt = strftime('%s', 'now') WHERE id IN (${placeholders})`, [status, ...ids]);
+            return Promise.resolve();
+        return getDrizzle(db).run(sql `
+      UPDATE asmr_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 asmr_library SET lastTrackIndex = ?, lastTrackLabel = ?, lastPosition = ?, updatedAt = strftime('%s', 'now') WHERE id = ?`, [progress.trackIndex, progress.trackLabel, progress.position, id]),
-    delete: (db, id) => dbRun(db, 'DELETE FROM asmr_library WHERE id = ?', [id]),
+    touchProgress: (db, id, progress) => getDrizzle(db).run(sql `
+      UPDATE asmr_library SET lastTrackIndex = ${progress.trackIndex}, lastTrackLabel = ${progress.trackLabel}, lastPosition = ${progress.position}, updatedAt = strftime('%s', 'now') WHERE id = ${id}`),
+    delete: (db, id) => getDrizzle(db).delete(asmrLibrary).where(eq(asmrLibrary.id, id)),
     deleteMany: (db, ids) => {
         if (ids.length === 0)
-            return;
-        const placeholders = ids.map(() => '?').join(', ');
-        dbRun(db, `DELETE FROM asmr_library WHERE id IN (${placeholders})`, ids);
+            return Promise.resolve();
+        return getDrizzle(db).delete(asmrLibrary).where(inArray(asmrLibrary.id, ids));
     },
 };
 export const AsmrProgressRepository = {
-    getByWork: (db, workId) => dbAll(db, 'SELECT workId, trackIndex, trackLabel, currentTime, duration, updatedAt FROM asmr_progress WHERE workId = ? ORDER BY updatedAt DESC', [workId]),
-    getTrack: (db, workId, trackIndex) => dbGet(db, 'SELECT workId, trackIndex, trackLabel, currentTime, duration, updatedAt FROM asmr_progress WHERE workId = ? AND trackIndex = ?', [workId, trackIndex]),
-    getLatest: (db, workId) => dbGet(db, 'SELECT workId, trackIndex, trackLabel, currentTime, duration, updatedAt FROM asmr_progress WHERE workId = ? ORDER BY updatedAt DESC LIMIT 1', [workId]),
-    upsert: (db, data) => dbRun(db, `INSERT INTO asmr_progress (workId, trackIndex, trackLabel, currentTime, duration, title, thumbnail, rjCode, isAdult, updatedAt)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, strftime('%s', 'now'))
-       ON CONFLICT(workId, trackIndex) DO UPDATE SET
-          trackLabel = COALESCE(NULLIF(EXCLUDED.trackLabel, ''), asmr_progress.trackLabel),
-          currentTime = EXCLUDED.currentTime,
-          duration = EXCLUDED.duration,
-          title = COALESCE(EXCLUDED.title, asmr_progress.title),
-          thumbnail = COALESCE(EXCLUDED.thumbnail, asmr_progress.thumbnail),
-          rjCode = COALESCE(EXCLUDED.rjCode, asmr_progress.rjCode),
-          isAdult = COALESCE(EXCLUDED.isAdult, asmr_progress.isAdult),
-          updatedAt = strftime('%s', 'now')`, [
-        data.workId,
-        data.trackIndex,
-        data.trackLabel,
-        data.currentTime,
-        data.duration,
-        data.title ?? null,
-        data.thumbnail ?? null,
-        data.rjCode ?? null,
-        data.isAdult ?? null,
-    ]),
-    deleteByWork: (db, workId) => dbRun(db, 'DELETE FROM asmr_progress WHERE workId = ?', [workId]),
+    getByWork: (db, workId) => getDrizzle(db).all(sql `
+      SELECT workId, trackIndex, trackLabel, currentTime, duration, updatedAt FROM asmr_progress WHERE workId = ${workId} ORDER BY updatedAt DESC`),
+    getTrack: async (db, workId, trackIndex) => {
+        const rows = await getDrizzle(db).all(sql `
+      SELECT workId, trackIndex, trackLabel, currentTime, duration, updatedAt FROM asmr_progress WHERE workId = ${workId} AND trackIndex = ${trackIndex}`);
+        return rows[0];
+    },
+    getLatest: async (db, workId) => {
+        const rows = await getDrizzle(db).all(sql `
+      SELECT workId, trackIndex, trackLabel, currentTime, duration, updatedAt FROM asmr_progress WHERE workId = ${workId} ORDER BY updatedAt DESC LIMIT 1`);
+        return rows[0];
+    },
+    upsert: (db, data) => getDrizzle(db).run(sql `
+      INSERT INTO asmr_progress (workId, trackIndex, trackLabel, currentTime, duration, title, thumbnail, rjCode, isAdult, updatedAt)
+      VALUES (${data.workId}, ${data.trackIndex}, ${data.trackLabel}, ${data.currentTime}, ${data.duration}, ${data.title ?? null}, ${data.thumbnail ?? null}, ${data.rjCode ?? null}, ${data.isAdult ?? null}, strftime('%s', 'now'))
+      ON CONFLICT(workId, trackIndex) DO UPDATE SET
+         trackLabel = COALESCE(NULLIF(EXCLUDED.trackLabel, ''), asmr_progress.trackLabel),
+         currentTime = EXCLUDED.currentTime,
+         duration = EXCLUDED.duration,
+         title = COALESCE(EXCLUDED.title, asmr_progress.title),
+         thumbnail = COALESCE(EXCLUDED.thumbnail, asmr_progress.thumbnail),
+         rjCode = COALESCE(EXCLUDED.rjCode, asmr_progress.rjCode),
+         isAdult = COALESCE(EXCLUDED.isAdult, asmr_progress.isAdult),
+         updatedAt = strftime('%s', 'now')`),
+    deleteByWork: (db, workId) => getDrizzle(db).delete(asmrProgress).where(eq(asmrProgress.workId, workId)),
     deleteMany: (db, ids) => {
         if (ids.length === 0)
-            return;
-        const placeholders = ids.map(() => '?').join(', ');
-        dbRun(db, `DELETE FROM asmr_progress WHERE workId IN (${placeholders})`, ids);
+            return Promise.resolve();
+        return getDrizzle(db).delete(asmrProgress).where(inArray(asmrProgress.workId, ids));
     },
-    deleteTrack: (db, workId, trackIndex) => dbRun(db, 'DELETE FROM asmr_progress WHERE workId = ? AND trackIndex = ?', [
-        workId,
-        trackIndex,
-    ]),
+    deleteTrack: (db, workId, trackIndex) => getDrizzle(db).run(sql `
+      DELETE FROM asmr_progress WHERE workId = ${workId} AND trackIndex = ${trackIndex}`),
     getContinueListening: (db, limit) => {
         const limitClause = typeof limit === 'number' ? `LIMIT ${limit}` : '';
-        return dbAll(db, `SELECT p.workId as id,
-              COALESCE(l.rjCode, p.rjCode, p.workId) as rjCode,
-              COALESCE(l.title, p.title) as title,
-              COALESCE(l.thumbnail, p.thumbnail) as thumbnail,
-              COALESCE(l.isAdult, p.isAdult) as isAdult,
-              l.status as watchlistStatus,
-              p.trackIndex, p.trackLabel, p.currentTime, p.duration, p.updatedAt as progressAt
-       FROM (
-         SELECT *, ROW_NUMBER() OVER (PARTITION BY workId ORDER BY updatedAt DESC) as rn
-         FROM asmr_progress
-       ) p
-       LEFT JOIN asmr_library l ON p.workId = l.id
-       WHERE p.rn = 1
-         AND (l.status IS NULL OR l.status = 'Listening')
-       ORDER BY p.updatedAt DESC
-       ${limitClause}`);
+        return getDrizzle(db).all(sql `
+      SELECT p.workId as id,
+             COALESCE(l.rjCode, p.rjCode, p.workId) as rjCode,
+             COALESCE(l.title, p.title) as title,
+             COALESCE(l.thumbnail, p.thumbnail) as thumbnail,
+             COALESCE(l.isAdult, p.isAdult) as isAdult,
+             l.status as watchlistStatus,
+             p.trackIndex, p.trackLabel, p.currentTime, p.duration, p.updatedAt as progressAt
+      FROM (
+        SELECT *, ROW_NUMBER() OVER (PARTITION BY workId ORDER BY updatedAt DESC) as rn
+        FROM asmr_progress
+      ) p
+      LEFT JOIN asmr_library l ON p.workId = l.id
+      WHERE p.rn = 1
+        AND (l.status IS NULL OR l.status = 'Listening')
+      ORDER BY p.updatedAt DESC
+      ${sql.raw(limitClause)}`);
     },
 };

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

@@ -1,6 +1,8 @@
-import { dbAll, dbGet } from '../utils/db-utils.js';
+import { sql } from 'drizzle-orm';
+import { getDrizzle } from '../db/drizzle.js';
 export const InsightsRepository = {
-    getCoreStats: (db) => dbGet(db, `SELECT
+    getCoreStats: async (db) => (await getDrizzle(db).all(sql `
+      SELECT
         (SELECT SUM(
           CASE WHEN we.currentTime > 0 THEN we.currentTime
                WHEN we.currentTime = 0 AND we.duration = 0 THEN
@@ -16,10 +18,13 @@ export const InsightsRepository = {
         (SELECT COUNT(*) FROM watched_episodes) as totalEpisodes,
         (SELECT COUNT(DISTINCT showId) FROM watched_episodes) as totalAnime,
         (SELECT COUNT(*) FROM watchlist WHERE status = 'Completed') as completedCount,
-        (SELECT COUNT(*) FROM watchlist) as totalWatchlist`),
-    getActivityGrid: (db) => dbAll(db, `SELECT date(watchedAt) as day, COUNT(*) as count FROM watched_episodes WHERE NOT (currentTime = 0 AND duration = 0) GROUP BY day`),
-    getHourlyDist: (db) => dbAll(db, `SELECT strftime('%H', watchedAt) as hour, COUNT(*) as count FROM watched_episodes WHERE NOT (currentTime = 0 AND duration = 0) GROUP BY hour`),
-    getSeasonality: (db) => dbAll(db, `SELECT strftime('%m', we.watchedAt) as month, SUM(
+        (SELECT COUNT(*) FROM watchlist) as totalWatchlist`))[0],
+    getActivityGrid: (db) => getDrizzle(db).all(sql `
+      SELECT date(watchedAt) as day, COUNT(*) as count FROM watched_episodes WHERE NOT (currentTime = 0 AND duration = 0) GROUP BY day`),
+    getHourlyDist: (db) => getDrizzle(db).all(sql `
+      SELECT strftime('%H', watchedAt) as hour, COUNT(*) as count FROM watched_episodes WHERE NOT (currentTime = 0 AND duration = 0) GROUP BY hour`),
+    getSeasonality: (db) => getDrizzle(db).all(sql `
+      SELECT strftime('%m', we.watchedAt) as month, SUM(
         CASE WHEN we.currentTime > 0 THEN we.currentTime
              WHEN we.currentTime = 0 AND we.duration = 0 THEN
                COALESCE(sm.episodeDuration * 60,
@@ -32,7 +37,8 @@ export const InsightsRepository = {
        FROM watched_episodes we
        LEFT JOIN shows_meta sm ON sm.id = we.showId
        GROUP BY month`),
-    getAllWatches: (db) => dbAll(db, `SELECT we.watchedAt, we.currentTime,
+    getAllWatches: (db) => getDrizzle(db).all(sql `
+      SELECT we.watchedAt, we.currentTime,
         CASE WHEN we.currentTime > 0 THEN we.currentTime
              WHEN we.currentTime = 0 AND we.duration = 0 THEN
                COALESCE(sm.episodeDuration * 60,
@@ -45,23 +51,27 @@ export const InsightsRepository = {
        FROM watched_episodes we
        LEFT JOIN shows_meta sm ON sm.id = we.showId
        ORDER BY we.watchedAt ASC`),
-    getWatchedShowsMeta: (db) => dbAll(db, `SELECT DISTINCT sm.id, sm.genres, sm.popularityScore
+    getWatchedShowsMeta: (db) => getDrizzle(db).all(sql `
+      SELECT DISTINCT sm.id, sm.genres, sm.popularityScore
       FROM shows_meta sm
       JOIN watched_episodes we ON sm.id = we.showId`),
-    getDroppedShows: (db) => dbAll(db, `SELECT w.id, w.name, MAX(we.watchedAt) as lastActivity
+    getDroppedShows: (db) => getDrizzle(db).all(sql `
+      SELECT w.id, w.name, MAX(we.watchedAt) as lastActivity
         FROM watchlist w
         JOIN watched_episodes we ON w.id = we.showId
         WHERE w.status = 'Watching' AND NOT (we.currentTime = 0 AND we.duration = 0)
         GROUP BY w.id
         HAVING lastActivity < date('now', '-90 days')`),
-    getCompletionVelocities: (db) => dbAll(db, `SELECT
+    getCompletionVelocities: (db) => getDrizzle(db).all(sql `
+      SELECT
         (julianday(MAX(we.watchedAt)) - julianday(MIN(we.watchedAt))) as daysToFinish
         FROM watchlist w
         JOIN watched_episodes we ON w.id = we.showId
         WHERE w.status = 'Completed'
         GROUP BY w.id
         HAVING SUM(we.currentTime) > 0`),
-    getWatchedEpisodesWithMeta: (db) => dbAll(db, `SELECT 
+    getWatchedEpisodesWithMeta: (db) => getDrizzle(db).all(sql `
+      SELECT
         we.showId,
         we.currentTime,
         we.duration,
@@ -82,7 +92,8 @@ export const InsightsRepository = {
         sm.thumbnail
       FROM watched_episodes we
       JOIN shows_meta sm ON we.showId = sm.id`),
-    getLibraryShowsWithGenres: (db) => dbAll(db, `SELECT
+    getLibraryShowsWithGenres: (db) => getDrizzle(db).all(sql `
+      SELECT
         w.id,
         w.status,
         COALESCE(NULLIF(sm.englishName, ''), sm.name, w.name) as title,
@@ -91,5 +102,5 @@ export const InsightsRepository = {
         COALESCE(sm.popularityScore, 0) as popularityScore
       FROM watchlist w
       LEFT JOIN shows_meta sm ON sm.id = w.id`),
-    getAllAnilistIds: (db) => dbAll(db, 'SELECT anilistId FROM shows_meta WHERE anilistId IS NOT NULL'),
+    getAllAnilistIds: (db) => getDrizzle(db).all(sql `SELECT anilistId FROM shows_meta WHERE anilistId IS NOT NULL`),
 };

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

@@ -1,4 +1,5 @@
-import { dbGet, dbRun } from '../utils/db-utils.js';
+import { sql } from 'drizzle-orm';
+import { getDrizzle } from '../db/drizzle.js';
 const LIBRARY_TABLES = [
     'watchlist',
     'watched_episodes',
@@ -12,97 +13,36 @@ const LIBRARY_TABLES = [
 const MANGA_LIBRARY_TABLES = ['manga_library', 'manga_progress'];
 const TV_LIBRARY_TABLES = ['tv_library', 'tv_progress'];
 const ASMR_LIBRARY_TABLES = ['asmr_library', 'asmr_progress'];
+async function countTables(db, tables) {
+    const counts = {};
+    for (const table of tables) {
+        try {
+            const rows = await getDrizzle(db).all(sql `SELECT COUNT(*) AS rows FROM ${sql.raw(`"${table}"`)}`);
+            counts[table] = rows[0]?.rows ?? 0;
+        }
+        catch {
+            counts[table] = 0;
+        }
+    }
+    return counts;
+}
+async function clearTables(db, tables) {
+    for (const table of tables) {
+        try {
+            await getDrizzle(db).run(sql `DELETE FROM ${sql.raw(`"${table}"`)}`);
+        }
+        catch {
+            // ignore
+        }
+    }
+}
 export const LibraryRepository = {
-    countAll: (db) => {
-        const counts = {};
-        for (const table of LIBRARY_TABLES) {
-            try {
-                counts[table] =
-                    dbGet(db, `SELECT COUNT(*) AS rows FROM "${table}"`)?.rows ?? 0;
-            }
-            catch {
-                counts[table] = 0;
-            }
-        }
-        return counts;
-    },
-    clearAll: (db) => {
-        for (const table of LIBRARY_TABLES) {
-            try {
-                dbRun(db, `DELETE FROM "${table}"`);
-            }
-            catch {
-                // ignore
-            }
-        }
-    },
-    countManga: (db) => {
-        const counts = {};
-        for (const table of MANGA_LIBRARY_TABLES) {
-            try {
-                counts[table] =
-                    dbGet(db, `SELECT COUNT(*) AS rows FROM "${table}"`)?.rows ?? 0;
-            }
-            catch {
-                counts[table] = 0;
-            }
-        }
-        return counts;
-    },
-    clearManga: (db) => {
-        for (const table of MANGA_LIBRARY_TABLES) {
-            try {
-                dbRun(db, `DELETE FROM "${table}"`);
-            }
-            catch {
-                // ignore
-            }
-        }
-    },
-    countTv: (db) => {
-        const counts = {};
-        for (const table of TV_LIBRARY_TABLES) {
-            try {
-                counts[table] =
-                    dbGet(db, `SELECT COUNT(*) AS rows FROM "${table}"`)?.rows ?? 0;
-            }
-            catch {
-                counts[table] = 0;
-            }
-        }
-        return counts;
-    },
-    clearTv: (db) => {
-        for (const table of TV_LIBRARY_TABLES) {
-            try {
-                dbRun(db, `DELETE FROM "${table}"`);
-            }
-            catch {
-                // ignore
-            }
-        }
-    },
-    countAsmr: (db) => {
-        const counts = {};
-        for (const table of ASMR_LIBRARY_TABLES) {
-            try {
-                counts[table] =
-                    dbGet(db, `SELECT COUNT(*) AS rows FROM "${table}"`)?.rows ?? 0;
-            }
-            catch {
-                counts[table] = 0;
-            }
-        }
-        return counts;
-    },
-    clearAsmr: (db) => {
-        for (const table of ASMR_LIBRARY_TABLES) {
-            try {
-                dbRun(db, `DELETE FROM "${table}"`);
-            }
-            catch {
-                // ignore
-            }
-        }
-    },
+    countAll: (db) => countTables(db, LIBRARY_TABLES),
+    clearAll: (db) => clearTables(db, LIBRARY_TABLES),
+    countManga: (db) => countTables(db, MANGA_LIBRARY_TABLES),
+    clearManga: (db) => clearTables(db, MANGA_LIBRARY_TABLES),
+    countTv: (db) => countTables(db, TV_LIBRARY_TABLES),
+    clearTv: (db) => clearTables(db, TV_LIBRARY_TABLES),
+    countAsmr: (db) => countTables(db, ASMR_LIBRARY_TABLES),
+    clearAsmr: (db) => clearTables(db, ASMR_LIBRARY_TABLES),
 };