@serifpersia/dango 3.6.7 → 3.6.8

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

@@ -1,7 +1,4 @@
-import { sql } from 'drizzle-orm';
-import { getDrizzle } from '../db/drizzle.js';
-export const InsightsRepository = {
-    getCoreStats: async (db) => (await getDrizzle(db).all(sql `
+import{sql as t}from"drizzle-orm";import{getDrizzle as s}from"../db/drizzle.js";const w={getCoreStats:async e=>(await s(e).all(t`
       SELECT
         (SELECT SUM(
           CASE WHEN we.currentTime > 0 THEN we.currentTime
@@ -18,12 +15,9 @@ 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`))[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 COUNT(*) FROM watchlist) as totalWatchlist`))[0],getActivityGrid:e=>s(e).all(t`
+      SELECT date(watchedAt) as day, COUNT(*) as count FROM watched_episodes WHERE NOT (currentTime = 0 AND duration = 0) GROUP BY day`),getHourlyDist:e=>s(e).all(t`
+      SELECT strftime('%H', watchedAt) as hour, COUNT(*) as count FROM watched_episodes WHERE NOT (currentTime = 0 AND duration = 0) GROUP BY hour`),getSeasonality:e=>s(e).all(t`
       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
@@ -36,8 +30,7 @@ export const InsightsRepository = {
              ELSE 0 END) as seconds
        FROM watched_episodes we
        LEFT JOIN shows_meta sm ON sm.id = we.showId
-       GROUP BY month`),
-    getAllWatches: (db) => getDrizzle(db).all(sql `
+       GROUP BY month`),getAllWatches:e=>s(e).all(t`
       SELECT we.watchedAt, we.currentTime,
         CASE WHEN we.currentTime > 0 THEN we.currentTime
              WHEN we.currentTime = 0 AND we.duration = 0 THEN
@@ -50,27 +43,23 @@ export const InsightsRepository = {
              ELSE 0 END as effectiveSeconds
        FROM watched_episodes we
        LEFT JOIN shows_meta sm ON sm.id = we.showId
-       ORDER BY we.watchedAt ASC`),
-    getWatchedShowsMeta: (db) => getDrizzle(db).all(sql `
+       ORDER BY we.watchedAt ASC`),getWatchedShowsMeta:e=>s(e).all(t`
       SELECT DISTINCT sm.id, sm.genres, sm.popularityScore
       FROM shows_meta sm
-      JOIN watched_episodes we ON sm.id = we.showId`),
-    getDroppedShows: (db) => getDrizzle(db).all(sql `
+      JOIN watched_episodes we ON sm.id = we.showId`),getDroppedShows:e=>s(e).all(t`
       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) => getDrizzle(db).all(sql `
+        HAVING lastActivity < date('now', '-90 days')`),getCompletionVelocities:e=>s(e).all(t`
       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) => getDrizzle(db).all(sql `
+        HAVING SUM(we.currentTime) > 0`),getWatchedEpisodesWithMeta:e=>s(e).all(t`
       SELECT
         we.showId,
         we.currentTime,
@@ -91,8 +80,7 @@ export const InsightsRepository = {
         sm.englishName,
         sm.thumbnail
       FROM watched_episodes we
-      JOIN shows_meta sm ON we.showId = sm.id`),
-    getLibraryShowsWithGenres: (db) => getDrizzle(db).all(sql `
+      JOIN shows_meta sm ON we.showId = sm.id`),getLibraryShowsWithGenres:e=>s(e).all(t`
       SELECT
         w.id,
         w.status,
@@ -101,6 +89,4 @@ export const InsightsRepository = {
         (SELECT COUNT(*) FROM watched_episodes we WHERE we.showId = w.id) as episodesWatched,
         COALESCE(sm.popularityScore, 0) as popularityScore
       FROM watchlist w
-      LEFT JOIN shows_meta sm ON sm.id = w.id`),
-    getAllAnilistIds: (db) => getDrizzle(db).all(sql `SELECT anilistId FROM shows_meta WHERE anilistId IS NOT NULL`),
-};
+      LEFT JOIN shows_meta sm ON sm.id = w.id`),getAllAnilistIds:e=>s(e).all(t`SELECT anilistId FROM shows_meta WHERE anilistId IS NOT NULL`)};export{w as InsightsRepository};

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

@@ -1,94 +1,3 @@
-import { sql } from 'drizzle-orm';
-import { getDrizzle } from '../db/drizzle.js';
-const LIBRARY_TABLES = [
-    'watchlist',
-    'watched_episodes',
-    'queue',
-    'shows_meta',
-    'dismissed_notifications',
-    'discovered_notifications',
-    'legacy_id_mapping',
-    'temp_show_ids',
-];
-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 function makeLibraryRepo(table) {
-    const t = sql.raw(`"${table}"`);
-    return {
-        getById: async (db, id) => {
-            const rows = await getDrizzle(db).all(sql `SELECT * FROM ${t} WHERE id = ${id}`);
-            return rows[0];
-        },
-        getAll: (db, status, limit, offset) => {
-            const q = sql `SELECT * FROM ${t}`;
-            if (status && status !== 'All') {
-                q.append(sql ` WHERE status = ${status}`);
-            }
-            q.append(sql ` ORDER BY updatedAt DESC`);
-            if (limit !== undefined && offset !== undefined) {
-                q.append(sql ` LIMIT ${limit} OFFSET ${offset}`);
-            }
-            return getDrizzle(db).all(q);
-        },
-        getCount: async (db, status) => {
-            if (status && status !== 'All') {
-                const rows = await getDrizzle(db).all(sql `SELECT COUNT(*) as total FROM ${t} WHERE status = ${status}`);
-                return rows[0]?.total || 0;
-            }
-            const rows = await getDrizzle(db).all(sql `SELECT COUNT(*) as total FROM ${t}`);
-            return rows[0]?.total || 0;
-        },
-        getIds: async (db) => {
-            const rows = await getDrizzle(db).all(sql `SELECT id FROM ${t}`);
-            return rows.map((r) => r.id);
-        },
-        updateStatus: (db, id, status) => getDrizzle(db).run(sql `
-      UPDATE ${t} SET status = ${status}, updatedAt = strftime('%s', 'now') WHERE id = ${id}`),
-        updateStatusMany: (db, ids, status) => {
-            if (ids.length === 0)
-                return Promise.resolve();
-            return getDrizzle(db).run(sql `
-      UPDATE ${t} SET status = ${status}, updatedAt = strftime('%s', 'now') WHERE id IN (${sql.join(ids.map((id) => sql `${id}`), sql `, `)})`);
-        },
-        delete: (db, id) => getDrizzle(db).run(sql `DELETE FROM ${t} WHERE id = ${id}`),
-        deleteMany: (db, ids) => {
-            if (ids.length === 0)
-                return Promise.resolve();
-            return getDrizzle(db).run(sql `DELETE FROM ${t} WHERE id IN (${sql.join(ids.map((id) => sql `${id}`), sql `, `)})`);
-        },
-    };
-}
-export const LibraryRepository = {
-    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),
-};
+import{sql as a}from"drizzle-orm";import{getDrizzle as n}from"../db/drizzle.js";const l=["watchlist","watched_episodes","queue","shows_meta","dismissed_notifications","discovered_notifications","legacy_id_mapping","temp_show_ids"],b=["manga_library","manga_progress"],m=["tv_library","tv_progress"],E=["asmr_library","asmr_progress"];async function u(e,o){const t={};for(const r of o)try{const s=await n(e).all(a`SELECT COUNT(*) AS rows FROM ${a.raw(`"${r}"`)}`);t[r]=s[0]?.rows??0}catch{t[r]=0}return t}async function c(e,o){for(const t of o)try{await n(e).run(a`DELETE FROM ${a.raw(`"${t}"`)}`)}catch{}}function A(e){const o=a.raw(`"${e}"`);return{getById:async(t,r)=>(await n(t).all(a`SELECT * FROM ${o} WHERE id = ${r}`))[0],getAll:(t,r,s,i)=>{const p=a`SELECT * FROM ${o}`;return r&&r!=="All"&&p.append(a` WHERE status = ${r}`),p.append(a` ORDER BY updatedAt DESC`),s!==void 0&&i!==void 0&&p.append(a` LIMIT ${s} OFFSET ${i}`),n(t).all(p)},getCount:async(t,r)=>r&&r!=="All"?(await n(t).all(a`SELECT COUNT(*) as total FROM ${o} WHERE status = ${r}`))[0]?.total||0:(await n(t).all(a`SELECT COUNT(*) as total FROM ${o}`))[0]?.total||0,getIds:async t=>(await n(t).all(a`SELECT id FROM ${o}`)).map(s=>s.id),updateStatus:(t,r,s)=>n(t).run(a`
+      UPDATE ${o} SET status = ${s}, updatedAt = strftime('%s', 'now') WHERE id = ${r}`),updateStatusMany:(t,r,s)=>r.length===0?Promise.resolve():n(t).run(a`
+      UPDATE ${o} SET status = ${s}, updatedAt = strftime('%s', 'now') WHERE id IN (${a.join(r.map(i=>a`${i}`),a`, `)})`),delete:(t,r)=>n(t).run(a`DELETE FROM ${o} WHERE id = ${r}`),deleteMany:(t,r)=>r.length===0?Promise.resolve():n(t).run(a`DELETE FROM ${o} WHERE id IN (${a.join(r.map(s=>a`${s}`),a`, `)})`)}}const L={countAll:e=>u(e,l),clearAll:e=>c(e,l),countManga:e=>u(e,b),clearManga:e=>c(e,b),countTv:e=>u(e,m),clearTv:e=>c(e,m),countAsmr:e=>u(e,E),clearAsmr:e=>c(e,E)};export{L as LibraryRepository,A as makeLibraryRepo};

package/server/dist/repositories/mal-cache.repository.js

@@ -1,52 +1 @@
-import { DatabaseSync } from 'node:sqlite';
-import fs from 'fs';
-import path from 'path';
-import { CONFIG } from '../config.js';
-import { DatabaseWrapper } from '../db.js';
-import { dbGet, dbRun } from '../utils/db-utils.js';
-export const MAL_CACHE_MAX_ROWS = 5000;
-const DEFAULT_TTL_SECONDS = 6 * 3600;
-function cacheFile() {
-    return path.join(CONFIG.ROOT, CONFIG.IS_DEV ? 'mal-cache.dev.db' : 'mal-cache.db');
-}
-let handle = null;
-function db() {
-    if (!handle) {
-        const file = cacheFile();
-        fs.mkdirSync(path.dirname(file), { recursive: true });
-        handle = new DatabaseWrapper(file, new DatabaseSync(file));
-        dbRun(handle, `CREATE TABLE IF NOT EXISTS mal_cache (key TEXT PRIMARY KEY, payload TEXT NOT NULL, fetched_at TEXT NOT NULL, expires_at TEXT NOT NULL)`);
-    }
-    return handle;
-}
-export function malCacheGet(key) {
-    const row = dbGet(db(), 'SELECT payload, fetched_at AS fetchedAt, expires_at AS expiresAt FROM mal_cache WHERE key = ?', [key]);
-    if (!row)
-        return null;
-    return { payload: row.payload, fresh: Date.now() < Date.parse(row.expiresAt) };
-}
-export function malCachePut(key, payload, ttlSeconds = DEFAULT_TTL_SECONDS) {
-    const database = db();
-    const now = new Date();
-    dbRun(database, 'INSERT OR REPLACE INTO mal_cache (key, payload, fetched_at, expires_at) VALUES (?, ?, ?, ?)', [key, payload, now.toISOString(), new Date(now.getTime() + ttlSeconds * 1000).toISOString()]);
-    const count = dbGet(database, 'SELECT COUNT(*) AS rows FROM mal_cache')?.rows ?? 0;
-    if (count < MAL_CACHE_MAX_ROWS)
-        return;
-    malCachePruneExpired();
-    const remaining = dbGet(database, 'SELECT COUNT(*) AS rows FROM mal_cache')?.rows ?? 0;
-    if (remaining < MAL_CACHE_MAX_ROWS)
-        return;
-    dbRun(database, `DELETE FROM mal_cache WHERE key NOT IN (SELECT key FROM mal_cache ORDER BY fetched_at DESC LIMIT ${MAL_CACHE_MAX_ROWS})`);
-}
-export function malCachePruneExpired() {
-    const now = new Date().toISOString();
-    const row = dbGet(db(), 'SELECT COUNT(*) AS rows FROM mal_cache WHERE expires_at < ?', [now]);
-    dbRun(db(), 'DELETE FROM mal_cache WHERE expires_at < ?', [now]);
-    return row?.rows ?? 0;
-}
-export function malCacheStore() {
-    return {
-        get: (key) => malCacheGet(key),
-        put: (key, payload, ttl) => malCachePut(key, payload, ttl),
-    };
-}
+import{DatabaseSync as p}from"node:sqlite";import T from"fs";import m from"path";import{CONFIG as l}from"../config.js";import{DatabaseWrapper as u}from"../db.js";import{dbGet as a,dbRun as n}from"../utils/db-utils.js";const s=5e3,S=6*3600;function h(){return m.join(l.ROOT,l.IS_DEV?"mal-cache.dev.db":"mal-cache.db")}let o=null;function c(){if(!o){const e=h();T.mkdirSync(m.dirname(e),{recursive:!0}),o=new u(e,new p(e)),n(o,"CREATE TABLE IF NOT EXISTS mal_cache (key TEXT PRIMARY KEY, payload TEXT NOT NULL, fetched_at TEXT NOT NULL, expires_at TEXT NOT NULL)")}return o}function f(e){const t=a(c(),"SELECT payload, fetched_at AS fetchedAt, expires_at AS expiresAt FROM mal_cache WHERE key = ?",[e]);return t?{payload:t.payload,fresh:Date.now()<Date.parse(t.expiresAt)}:null}function O(e,t,i=S){const r=c(),E=new Date;n(r,"INSERT OR REPLACE INTO mal_cache (key, payload, fetched_at, expires_at) VALUES (?, ?, ?, ?)",[e,t,E.toISOString(),new Date(E.getTime()+i*1e3).toISOString()]),!((a(r,"SELECT COUNT(*) AS rows FROM mal_cache")?.rows??0)<s||(d(),(a(r,"SELECT COUNT(*) AS rows FROM mal_cache")?.rows??0)<s))&&n(r,`DELETE FROM mal_cache WHERE key NOT IN (SELECT key FROM mal_cache ORDER BY fetched_at DESC LIMIT ${s})`)}function d(){const e=new Date().toISOString(),t=a(c(),"SELECT COUNT(*) AS rows FROM mal_cache WHERE expires_at < ?",[e]);return n(c(),"DELETE FROM mal_cache WHERE expires_at < ?",[e]),t?.rows??0}function N(){return{get:e=>f(e),put:(e,t,i)=>O(e,t,i)}}export{s as MAL_CACHE_MAX_ROWS,f as malCacheGet,d as malCachePruneExpired,O as malCachePut,N as malCacheStore};

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

@@ -1,16 +1,6 @@
-import { eq, inArray, sql } from 'drizzle-orm';
-import { getDrizzle } from '../db/drizzle.js';
-import { mangaLibrary, mangaProgress } from '../db/schema-manga.js';
-import { makeLibraryRepo } from './library.repository.js';
-export const MANGA_STATUSES = ['Reading', 'Completed', 'On-Hold', 'Dropped', 'Planned'];
-export function buildMangaId(provider, mangaId) {
-    return `${provider.toLowerCase()}:${mangaId}`;
-}
-export const MangaLibraryRepository = {
-    ...makeLibraryRepo('manga_library'),
-    upsert: (db, data) => getDrizzle(db).run(sql `
+import{eq as l,inArray as p,sql as n}from"drizzle-orm";import{getDrizzle as e}from"../db/drizzle.js";import{mangaLibrary as i,mangaProgress as s}from"../db/schema-manga.js";import{makeLibraryRepo as o}from"./library.repository.js";const I=["Reading","Completed","On-Hold","Dropped","Planned"];function L(a,t){return`${a.toLowerCase()}:${t}`}const D={...o("manga_library"),upsert:(a,t)=>e(a).run(n`
       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'))
+      VALUES (${t.id}, ${t.provider}, ${t.mangaId}, ${t.title}, ${t.cover}, ${t.status}, ${t.author||null}, ${t.altTitle||null}, ${t.contentRating||null}, ${t.anilistId??null}, ${t.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),
@@ -21,34 +11,14 @@ export const MangaLibraryRepository = {
          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
-        ? getDrizzle(db)
-            .update(mangaLibrary)
-            .set({ anilistId, anilistIdSource: source })
-            .where(eq(mangaLibrary.id, id))
-        : getDrizzle(db).update(mangaLibrary).set({ anilistId }).where(eq(mangaLibrary.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}`),
-};
-export const MangaProgressRepository = {
-    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 `
+         updatedAt = strftime('%s', 'now')`),setAnilistId:(a,t,r,g)=>g?e(a).update(i).set({anilistId:r,anilistIdSource:g}).where(l(i.id,t)):e(a).update(i).set({anilistId:r}).where(l(i.id,t)),touchProgress:(a,t,r)=>e(a).run(n`
+      UPDATE manga_library SET lastChapterId = ${r.chapterId}, lastChapterNumber = ${r.chapterNumber}, lastPage = ${r.page}, updatedAt = strftime('%s', 'now') WHERE id = ${t}`),setProgressPointer:(a,t,r)=>e(a).run(n`
+      UPDATE manga_library SET lastChapterNumber = ${r}, updatedAt = strftime('%s', 'now') WHERE id = ${t}`)},b={getByManga:(a,t)=>e(a).all(n`
+      SELECT mangaId, chapterId, chapterNumber, page, pageCount, updatedAt FROM manga_progress WHERE mangaId = ${t} ORDER BY updatedAt DESC`),getChapter:async(a,t,r)=>(await e(a).all(n`
+      SELECT mangaId, chapterId, chapterNumber, page, pageCount, updatedAt FROM manga_progress WHERE mangaId = ${t} AND chapterId = ${r}`))[0],getLatest:async(a,t)=>(await e(a).all(n`
+      SELECT mangaId, chapterId, chapterNumber, page, pageCount, updatedAt FROM manga_progress WHERE mangaId = ${t} ORDER BY updatedAt DESC LIMIT 1`))[0],upsert:(a,t)=>e(a).run(n`
       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'))
+      VALUES (${t.mangaId}, ${t.chapterId}, ${t.chapterNumber}, ${t.page}, ${t.pageCount}, ${t.title??null}, ${t.cover??null}, ${t.provider??null}, ${t.altTitle??null}, ${t.contentRating??null}, strftime('%s', 'now'))
       ON CONFLICT(mangaId, chapterId) DO UPDATE SET
          chapterNumber = COALESCE(NULLIF(EXCLUDED.chapterNumber, ''), manga_progress.chapterNumber),
          page = EXCLUDED.page,
@@ -58,22 +28,10 @@ export const MangaProgressRepository = {
          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 Promise.resolve();
-        return getDrizzle(db).delete(mangaProgress).where(inArray(mangaProgress.mangaId, ids));
-    },
-    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 getDrizzle(db).all(sql `
+         updatedAt = strftime('%s', 'now')`),deleteByManga:(a,t)=>e(a).delete(s).where(l(s.mangaId,t)),deleteMany:(a,t)=>t.length===0?Promise.resolve():e(a).delete(s).where(p(s.mangaId,t)),deleteChapter:(a,t,r)=>e(a).run(n`
+      DELETE FROM manga_progress WHERE mangaId = ${t} AND chapterId = ${r}`),deleteSyntheticChapters:(a,t,r)=>e(a).run(n`
+      DELETE FROM manga_progress WHERE mangaId = ${t} AND chapterId LIKE 'anilist:ch:%' AND chapterId != ${r}`),moveSyntheticChapters:(a,t,r)=>e(a).run(n`
+      UPDATE manga_progress SET mangaId = ${r}, updatedAt = strftime('%s', 'now') WHERE mangaId = ${t} AND chapterId LIKE 'anilist:ch:%'`),getContinueReading:(a,t)=>{const r=typeof t=="number"?`LIMIT ${t}`:"";return e(a).all(n`
       SELECT p.mangaId as id,
              COALESCE(l.mangaId, SUBSTR(p.mangaId, INSTR(p.mangaId, ':') + 1)) as mangaId,
              COALESCE(l.provider, p.provider) as provider,
@@ -90,6 +48,4 @@ export const MangaProgressRepository = {
       WHERE p.rn = 1
         AND (l.status IS NULL OR l.status = 'Reading')
       ORDER BY p.updatedAt DESC
-      ${sql.raw(limitClause)}`);
-    },
-};
+      ${n.raw(r)}`)}};export{I as MANGA_STATUSES,D as MangaLibraryRepository,b as MangaProgressRepository,L as buildMangaId};

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

@@ -1,51 +1,8 @@
-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) => 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 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([
-        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([
-        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: 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 `
+import{and as n,eq as t,sql as o}from"drizzle-orm";import{getDrizzle as i}from"../db/drizzle.js";import{discoveredNotifications as d,dismissedNotifications as a}from"../db/schema-anime.js";const N={getDismissedByShow:(e,s)=>i(e).all(o`SELECT episodeNumber FROM dismissed_notifications WHERE showId = ${s}`),getDiscoveredByShow:(e,s)=>i(e).all(o`SELECT episodeNumber FROM discovered_notifications WHERE showId = ${s}`),addDiscovered:(e,s,r)=>i(e).insert(d).values({showId:s,episodeNumber:r}).onConflictDoNothing(),addDismissed:(e,s,r)=>i(e).insert(a).values({showId:s,episodeNumber:r}).onConflictDoNothing(),dismissFromDiscovered:(e,s)=>s?i(e).run(o`
+        INSERT OR IGNORE INTO dismissed_notifications (showId, episodeNumber) SELECT showId, episodeNumber FROM discovered_notifications WHERE showId = ${s}`):i(e).run(o`
+      INSERT OR IGNORE INTO dismissed_notifications (showId, episodeNumber) SELECT showId, episodeNumber FROM discovered_notifications`),deleteByShow:(e,s)=>Promise.all([i(e).delete(a).where(t(a.showId,s)),i(e).delete(d).where(t(d.showId,s))]),deleteSpecificDismissed:(e,s,r)=>i(e).delete(a).where(n(t(a.showId,s),t(a.episodeNumber,r))),deleteDiscovered:(e,s,r)=>i(e).delete(d).where(n(t(d.showId,s),t(d.episodeNumber,r))),cleanupWatchedNotifications:e=>Promise.all([i(e).run(o`
+        DELETE FROM dismissed_notifications WHERE EXISTS (SELECT 1 FROM watched_episodes we WHERE we.showId = dismissed_notifications.showId AND we.episodeNumber = dismissed_notifications.episodeNumber)`),i(e).run(o`
+        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:async e=>((await i(e).all(o`SELECT COUNT(*) as count FROM discovered_notifications`))[0]?.count||0)>0,hasActiveNotifications:async e=>((await i(e).all(o`
       SELECT COUNT(*) as count FROM discovered_notifications dn
       WHERE NOT EXISTS (
         SELECT 1 FROM dismissed_notifications dn2
@@ -54,7 +11,4 @@ export const NotificationsRepository = {
       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;
-    },
-};
+      )`))[0]?.count||0)>0};export{N as NotificationsRepository};

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

@@ -1,8 +1,4 @@
-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) => getDrizzle(db).all(sql `
+import{and as n,eq as o,sql as u}from"drizzle-orm";import{getDrizzle as s}from"../db/drizzle.js";import{queue as i}from"../db/schema-anime.js";const d={getAll:e=>s(e).all(u`
       SELECT
         q.id,
         q.showId,
@@ -16,57 +12,8 @@ export const QueueRepository = {
       FROM queue q
       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: 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 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) => getDrizzle(db).run(sql `
+      ORDER BY q.queue_order ASC, q.id ASC`),getByEpisode:async(e,a,r)=>(await s(e).all(u`SELECT * FROM queue WHERE showId = ${a} AND episodeNumber = ${r}`))[0],getByShow:(e,a)=>s(e).all(u`SELECT * FROM queue WHERE showId = ${a} ORDER BY queue_order ASC`),getMaxOrder:async e=>(await s(e).all(u`SELECT COALESCE(MAX(queue_order), -1) as maxOrder FROM queue`))[0]?.maxOrder??-1,addToEnd:(e,a,r)=>s(e).run(u`
       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;
-        let nextOrder = (await QueueRepository.getMaxOrder(db)) + 1;
-        for (const episode of episodes) {
-            const existing = await QueueRepository.getByEpisode(db, episode.showId, episode.episodeNumber);
-            if (existing)
-                continue;
-            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();
-        return getDrizzle(db).run(sql `
-      DELETE FROM queue WHERE showId = ${showId} AND episodeNumber IN (${sql.join(episodeNumbers.map((e) => sql `${e}`), sql `, `)})`);
-    },
-    clear: (db) => getDrizzle(db).delete(queue),
-    reorder: (db, items) => Promise.all(items.map((item, index) => {
-        if (item.id !== undefined) {
-            return getDrizzle(db)
-                .update(queue)
-                .set({ queueOrder: index })
-                .where(eq(queue.id, item.id));
-        }
-        return getDrizzle(db)
-            .update(queue)
-            .set({ queueOrder: index })
-            .where(and(eq(queue.showId, item.showId ?? ''), eq(queue.episodeNumber, item.episodeNumber ?? '')));
-    })),
-    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)`),
-};
+      (${a}, ${r}, (SELECT COALESCE(MAX(queue_order), -1) + 1 FROM queue))`),removeEpisode:(e,a,r)=>s(e).delete(i).where(n(o(i.showId,a),o(i.episodeNumber,r))),addManyToEnd:async(e,a)=>{if(a.length===0)return;let r=await d.getMaxOrder(e)+1;for(const t of a)await d.getByEpisode(e,t.showId,t.episodeNumber)||(await s(e).insert(i).values({showId:t.showId,episodeNumber:t.episodeNumber,queueOrder:r}),r+=1)},removeMany:(e,a,r)=>r.length===0?Promise.resolve():s(e).run(u`
+      DELETE FROM queue WHERE showId = ${a} AND episodeNumber IN (${u.join(r.map(t=>u`${t}`),u`, `)})`),clear:e=>s(e).delete(i),reorder:(e,a)=>Promise.all(a.map((r,t)=>r.id!==void 0?s(e).update(i).set({queueOrder:t}).where(o(i.id,r.id)):s(e).update(i).set({queueOrder:t}).where(n(o(i.showId,r.showId??""),o(i.episodeNumber,r.episodeNumber??""))))),cleanupOrphanedShowsMeta:e=>s(e).run(u`
+      DELETE FROM shows_meta WHERE id NOT IN (SELECT id FROM watchlist) AND id NOT IN (SELECT showId FROM queue)`)};export{d as QueueRepository};

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

@@ -1,30 +1,3 @@
-import { eq, sql } from 'drizzle-orm';
-import { getDrizzle } from '../db/drizzle.js';
-import { settings, watchlist } from '../db/schema-anime.js';
-export const SettingsRepository = {
-    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)),
-    readContinueFlags: async (db, ignoreKey, listOnlyKey) => {
-        const ignoreRow = await SettingsRepository.getByKey(db, ignoreKey);
-        const listOnlyRow = await SettingsRepository.getByKey(db, listOnlyKey);
-        return {
-            ignoreAdult: ignoreRow ? ignoreRow.value !== 'false' : true,
-            listOnly: listOnlyRow ? listOnlyRow.value === 'true' || listOnlyRow.value === '1' : false,
-        };
-    },
-    clearWatchlist: (db) => getDrizzle(db).delete(watchlist),
-    upsertWatchlistBatch: (db, shows) => {
-        if (shows.length === 0)
-            return Promise.resolve();
-        return getDrizzle(db).run(sql `
+import{eq as g,sql as r}from"drizzle-orm";import{getDrizzle as s}from"../db/drizzle.js";import{settings as n,watchlist as p}from"../db/schema-anime.js";const o={getByKey:async(t,e)=>(await s(t).all(r`SELECT value FROM settings WHERE key = ${e}`))[0],upsert:(t,e,a)=>s(t).insert(n).values({key:e,value:a}).onConflictDoUpdate({target:n.key,set:{value:a}}),deleteByKey:(t,e)=>s(t).delete(n).where(g(n.key,e)),readContinueFlags:async(t,e,a)=>{const l=await o.getByKey(t,e),i=await o.getByKey(t,a);return{ignoreAdult:l?l.value!=="false":!0,listOnly:i?i.value==="true"||i.value==="1":!1}},clearWatchlist:t=>s(t).delete(p),upsertWatchlistBatch:(t,e)=>e.length===0?Promise.resolve():s(t).run(r`
       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 `, `)}`);
-    },
-};
+      ${r.join(e.map(a=>r`(${a.id}, ${a.name}, ${a.thumbnail??null}, ${a.status})`),r`, `)}`)};export{o as SettingsRepository};

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

@@ -1,58 +1,5 @@
-import { eq, sql } from 'drizzle-orm';
-import { getDrizzle } from '../db/drizzle.js';
-import { showsMeta } from '../db/schema-anime.js';
-export const ShowsMetaRepository = {
-    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 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})`,
-            },
-        });
-    },
-    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 `
+import{eq as r,sql as i}from"drizzle-orm";import{getDrizzle as a}from"../db/drizzle.js";import{showsMeta as s}from"../db/schema-anime.js";const E={getById:async(n,e)=>(await a(n).all(i`SELECT * FROM shows_meta WHERE id = ${e}`))[0],getStatus:async(n,e)=>(await a(n).all(i`SELECT status FROM shows_meta WHERE id = ${e}`))[0]?.status,upsert:(n,e)=>{const t={id:e.id,name:e.name??null,thumbnail:e.thumbnail??null,nativeName:e.nativeName??null,englishName:e.englishName??null,genres:e.genres??null,popularityScore:e.popularityScore??null,status:e.status??null,episodeCount:e.episodeCount??null,type:e.type??null,anilistId:e.anilistId??null,isAdult:e.isAdult??null,episodeDuration:e.episodeDuration??null};return a(n).insert(s).values(t).onConflictDoUpdate({target:s.id,set:{name:i`COALESCE(NULLIF(${t.name}, ''), ${s.name})`,thumbnail:i`COALESCE(NULLIF(${t.thumbnail}, ''), ${s.thumbnail})`,nativeName:i`COALESCE(NULLIF(${t.nativeName}, ''), ${s.nativeName})`,englishName:i`COALESCE(NULLIF(${t.englishName}, ''), ${s.englishName})`,genres:i`COALESCE(NULLIF(${t.genres}, ''), ${s.genres})`,popularityScore:i`COALESCE(${t.popularityScore}, ${s.popularityScore})`,status:i`COALESCE(NULLIF(${t.status}, ''), ${s.status})`,episodeCount:i`COALESCE(${t.episodeCount}, ${s.episodeCount})`,type:i`COALESCE(NULLIF(${t.type}, ''), ${s.type})`,anilistId:i`COALESCE(${t.anilistId}, ${s.anilistId})`,isAdult:i`COALESCE(${t.isAdult}, ${s.isAdult})`,episodeDuration:i`COALESCE(NULLIF(${t.episodeDuration}, 0), ${s.episodeDuration})`}})},updateEpisodeCount:(n,e,t)=>a(n).update(s).set({episodeCount:t}).where(r(s.id,e)),updateStatus:(n,e,t)=>a(n).update(s).set({status:t}).where(r(s.id,e)),cleanupOrphanedMeta:n=>a(n).run(i`
+      DELETE FROM shows_meta WHERE id NOT IN (SELECT id FROM watchlist) AND id NOT IN (SELECT showId FROM queue)`),getShowIdsMissingMeta:n=>a(n).all(i`
       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) = ''`),
-};
+      WHERE sm.thumbnail IS NULL OR TRIM(sm.thumbnail) = ''`)};export{E as ShowsMetaRepository};