@serifpersia/dango 3.3.8 → 3.4.0

package/server/dist/db/schema-anime.js

@@ -0,0 +1,64 @@
+import { integer, primaryKey, real, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+export const watchedEpisodes = sqliteTable('watched_episodes', {
+    showId: text('showId').notNull(),
+    episodeNumber: text('episodeNumber').notNull(),
+    watchedAt: text('watchedAt'),
+    currentTime: real('currentTime'),
+    duration: real('duration'),
+}, (t) => [primaryKey({ columns: [t.showId, t.episodeNumber] })]);
+export const watchlist = sqliteTable('watchlist', {
+    id: text('id').notNull(),
+    name: text('name'),
+    thumbnail: text('thumbnail'),
+    status: text('status'),
+    nativeName: text('nativeName'),
+    englishName: text('englishName'),
+    type: text('type'),
+}, (t) => [primaryKey({ columns: [t.id] })]);
+export const showsMeta = sqliteTable('shows_meta', {
+    id: text('id').notNull(),
+    name: text('name'),
+    thumbnail: text('thumbnail'),
+    nativeName: text('nativeName'),
+    englishName: text('englishName'),
+    episodeCount: integer('episodeCount'),
+    status: text('status'),
+    genres: text('genres'),
+    popularityScore: integer('popularityScore'),
+    type: text('type'),
+    anilistId: integer('anilistId'),
+    isAdult: integer('isAdult'),
+    episodeDuration: integer('episodeDuration'),
+}, (t) => [primaryKey({ columns: [t.id] })]);
+export const settings = sqliteTable('settings', {
+    key: text('key').notNull(),
+    value: text('value'),
+}, (t) => [primaryKey({ columns: [t.key] })]);
+export const queue = sqliteTable('queue', {
+    id: integer('id'),
+    showId: text('showId').notNull(),
+    episodeNumber: text('episodeNumber').notNull(),
+    queueOrder: integer('queue_order').notNull(),
+});
+export const discoveredNotifications = sqliteTable('discovered_notifications', {
+    showId: text('showId').notNull(),
+    episodeNumber: text('episodeNumber').notNull(),
+    discoveredAt: text('discoveredAt'),
+}, (t) => [primaryKey({ columns: [t.showId, t.episodeNumber] })]);
+export const dismissedNotifications = sqliteTable('dismissed_notifications', {
+    showId: text('showId').notNull(),
+    episodeNumber: text('episodeNumber').notNull(),
+    dismissedAt: text('dismissedAt'),
+}, (t) => [primaryKey({ columns: [t.showId, t.episodeNumber] })]);
+export const tempShowIds = sqliteTable('temp_show_ids', {
+    id: text('id').notNull(),
+    provider: text('provider').notNull(),
+    nativeId: text('nativeId').notNull(),
+    title: text('title').notNull(),
+    thumbnail: text('thumbnail'),
+    createdAt: integer('createdAt').notNull(),
+}, (t) => [primaryKey({ columns: [t.id] })]);
+export const legacyIdMapping = sqliteTable('legacy_id_mapping', {
+    legacyId: text('legacyId').notNull(),
+    numericId: text('numericId'),
+}, (t) => [primaryKey({ columns: [t.legacyId] })]);

package/server/dist/db/schema-asmr.js

@@ -0,0 +1,25 @@
+import { integer, primaryKey, real, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+export const asmrLibrary = sqliteTable('asmr_library', {
+    id: text('id').notNull(),
+    rjCode: text('rjCode').notNull(),
+    title: text('title'),
+    thumbnail: text('thumbnail'),
+    status: text('status'),
+    isAdult: integer('isAdult'),
+    lastTrackIndex: integer('lastTrackIndex'),
+    lastTrackLabel: text('lastTrackLabel'),
+    lastPosition: real('lastPosition'),
+    updatedAt: integer('updatedAt'),
+}, (t) => [primaryKey({ columns: [t.id] })]);
+export const asmrProgress = sqliteTable('asmr_progress', {
+    workId: text('workId').notNull(),
+    trackIndex: integer('trackIndex').notNull(),
+    trackLabel: text('trackLabel'),
+    currentTime: real('currentTime'),
+    duration: real('duration'),
+    updatedAt: integer('updatedAt'),
+    title: text('title'),
+    thumbnail: text('thumbnail'),
+    rjCode: text('rjCode'),
+    isAdult: integer('isAdult'),
+}, (t) => [primaryKey({ columns: [t.workId, t.trackIndex] })]);

package/server/dist/db/schema-manga.js

@@ -0,0 +1,31 @@
+import { integer, primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+export const mangaLibrary = sqliteTable('manga_library', {
+    id: text('id').notNull(),
+    provider: text('provider').notNull(),
+    mangaId: text('mangaId').notNull(),
+    title: text('title'),
+    cover: text('cover'),
+    status: text('status'),
+    author: text('author'),
+    altTitle: text('altTitle'),
+    contentRating: text('contentRating'),
+    lastChapterId: text('lastChapterId'),
+    lastChapterNumber: text('lastChapterNumber'),
+    lastPage: integer('lastPage'),
+    updatedAt: integer('updatedAt'),
+    anilistId: integer('anilistId'),
+    anilistIdSource: text('anilistIdSource'),
+}, (t) => [primaryKey({ columns: [t.id] })]);
+export const mangaProgress = sqliteTable('manga_progress', {
+    mangaId: text('mangaId').notNull(),
+    chapterId: text('chapterId').notNull(),
+    chapterNumber: text('chapterNumber'),
+    page: integer('page'),
+    pageCount: integer('pageCount'),
+    updatedAt: integer('updatedAt'),
+    title: text('title'),
+    cover: text('cover'),
+    provider: text('provider'),
+    altTitle: text('altTitle'),
+    contentRating: text('contentRating'),
+}, (t) => [primaryKey({ columns: [t.mangaId, t.chapterId] })]);

package/server/dist/db/schema-tv.js

@@ -0,0 +1,33 @@
+import { integer, primaryKey, real, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+export const tvLibrary = sqliteTable('tv_library', {
+    id: text('id').notNull(),
+    tmdbId: integer('tmdbId').notNull(),
+    mediaType: text('mediaType').notNull(),
+    title: text('title'),
+    poster: text('poster'),
+    backdrop: text('backdrop'),
+    year: text('year'),
+    overview: text('overview'),
+    status: text('status'),
+    adult: integer('adult'),
+    lastSeason: integer('lastSeason'),
+    lastEpisode: integer('lastEpisode'),
+    updatedAt: integer('updatedAt'),
+}, (t) => [primaryKey({ columns: [t.id] })]);
+export const tvProgress = sqliteTable('tv_progress', {
+    mediaId: text('mediaId').notNull(),
+    season: integer('season').notNull(),
+    episode: integer('episode').notNull(),
+    currentTime: real('currentTime'),
+    duration: real('duration'),
+    updatedAt: integer('updatedAt'),
+    title: text('title'),
+    poster: text('poster'),
+    backdrop: text('backdrop'),
+    year: text('year'),
+    overview: text('overview'),
+    tmdbId: integer('tmdbId'),
+    mediaType: text('mediaType'),
+    adult: integer('adult'),
+    completed: integer('completed'),
+}, (t) => [primaryKey({ columns: [t.mediaId, t.season, t.episode] })]);

package/server/dist/db.js

@@ -1,11 +1,15 @@
 import { DatabaseSync } from 'node:sqlite';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import fs from 'fs';
 import path from 'path';
 import logger from './logger.js';
+const txOwner = new AsyncLocalStorage();
 export class DatabaseWrapper {
     db;
     isClosed = false;
     statementCache = new Map();
+    txDepth = 0;
+    txQueue = Promise.resolve();
     constructor(_dbPath, db) {
         this.db = db;
     }
@@ -31,15 +35,82 @@ export class DatabaseWrapper {
         }
     }
     serialize(cb) {
-        this.db.exec('BEGIN IMMEDIATE');
+        const outer = this.txDepth === 0;
+        const level = this.txDepth;
+        this.run(outer ? 'BEGIN IMMEDIATE' : `SAVEPOINT dango_sp_${level}`);
+        this.txDepth = level + 1;
         try {
-            cb();
-            this.db.exec('COMMIT');
+            txOwner.run(this, cb);
         }
         catch (e) {
-            this.db.exec('ROLLBACK');
+            this.txDepth = level;
+            try {
+                this.run(outer ? 'ROLLBACK' : `ROLLBACK TO SAVEPOINT dango_sp_${level}`);
+            }
+            catch {
+                // ignore
+            }
             throw e;
         }
+        this.txDepth = level;
+        this.run(outer ? 'COMMIT' : `RELEASE SAVEPOINT dango_sp_${level}`);
+    }
+    acquireTxQueue() {
+        const prev = this.txQueue;
+        let release;
+        const current = new Promise((res) => {
+            release = res;
+        });
+        this.txQueue = prev.then(() => current);
+        return prev.then(() => release);
+    }
+    async transact(fn) {
+        if (txOwner.getStore() === this) {
+            const level = this.txDepth;
+            this.run(`SAVEPOINT dango_sp_${level}`);
+            this.txDepth = level + 1;
+            try {
+                await fn(this);
+            }
+            catch (e) {
+                this.txDepth = level;
+                try {
+                    this.run(`ROLLBACK TO SAVEPOINT dango_sp_${level}`);
+                }
+                catch {
+                    // ignore
+                }
+                throw e;
+            }
+            this.txDepth = level;
+            this.run(`RELEASE SAVEPOINT dango_sp_${level}`);
+            return;
+        }
+        const release = await this.acquireTxQueue();
+        try {
+            await txOwner.run(this, async () => {
+                this.run('BEGIN IMMEDIATE');
+                this.txDepth = 1;
+                try {
+                    await fn(this);
+                }
+                catch (e) {
+                    this.txDepth = 0;
+                    try {
+                        this.run('ROLLBACK');
+                    }
+                    catch {
+                        // ignore
+                    }
+                    throw e;
+                }
+                this.txDepth = 0;
+                this.run('COMMIT');
+            });
+        }
+        finally {
+            release();
+        }
     }
     close(cb) {
         if (this.isClosed) {

package/server/dist/discord-gateway.js

@@ -339,7 +339,7 @@ class DiscordGatewayService {
                     }
                 }
                 else if (msg.op === 11) {
-                    // heartbeat ack
+                    // ignore
                 }
                 else if (msg.op === 0) {
                     if (msg.t === 'READY') {

package/server/dist/google.js

@@ -13,8 +13,6 @@ export class GoogleDriveService {
     tokens = {};
     folderIdCache = new Map();
     constructor() {
-        // Client ID/secret now live in Cloudflare Worker (GOOGLE_AUTH_WORKER_URL).
-        // Legacy user-owned .env credentials are optional fallback only.
         if (!CONFIG.GOOGLE_AUTH_WORKER_URL && !CONFIG.GOOGLE_CLIENT_ID) {
             logger.error('GOOGLE_AUTH_WORKER_URL is missing and no GOOGLE_CLIENT_ID fallback!');
         }
@@ -47,7 +45,6 @@ export class GoogleDriveService {
         }
     }
     getGoogleClientConfig() {
-        // Legacy fallback only. Preferred path is Worker (no secret in dango).
         return {
             clientId: CONFIG.GOOGLE_CLIENT_ID || '',
             clientSecret: CONFIG.GOOGLE_CLIENT_SECRET || '',
@@ -95,7 +92,6 @@ export class GoogleDriveService {
         if (!this.tokens.refresh_token) {
             throw new Error('Missing refresh token');
         }
-        // Preferred: secret stays in Worker
         if (this.useWorker()) {
             await this.refreshViaWorker();
             return;
@@ -206,7 +202,6 @@ export class GoogleDriveService {
         return !!this.tokens.refresh_token;
     }
     async getAuthUrl() {
-        // Preferred: Worker builds URL with bundled client_id, no secret needed here
         if (this.useWorker()) {
             try {
                 const url = new URL(`${CONFIG.GOOGLE_AUTH_WORKER_URL}/auth-url`);
@@ -235,7 +230,6 @@ export class GoogleDriveService {
         return url.toString();
     }
     async handleCallback(code) {
-        // Preferred: Worker exchanges code with secret, dango never sees secret
         if (this.useWorker()) {
             try {
                 const data = await this.postJson(`${CONFIG.GOOGLE_AUTH_WORKER_URL}/exchange`, { code, redirect_uri: CONFIG.GOOGLE_REDIRECT_URI });
@@ -247,7 +241,6 @@ export class GoogleDriveService {
                 throw error;
             }
         }
-        // Legacy fallback: user-owned client_id/secret in .env
         const { clientId, clientSecret } = this.getGoogleClientConfig();
         const params = new URLSearchParams({
             code,

package/server/dist/hono/asmr.js

@@ -0,0 +1 @@
+export {};

package/server/dist/hono/auth.js

@@ -0,0 +1,56 @@
+import logger from '../logger.js';
+import { googleDriveService } from '../google.js';
+import { CONFIG } from '../config.js';
+import { updateEnvFile } from '../utils/env.utils.js';
+export function registerAuth(app, getDbs, runSync) {
+    app.get('/api/auth/google/callback', async (c) => {
+        const code = c.req.query('code');
+        if (!code) {
+            return c.text('No code provided', 400);
+        }
+        await googleDriveService.handleCallback(code);
+        const user = await googleDriveService.getUserProfile();
+        await updateEnvFile({ SYNC_PROVIDER: 'google' });
+        logger.info('User logged in. Syncing database (please wait)...');
+        const dbs = getDbs();
+        try {
+            await runSync(dbs.db, dbs.mangaDb, 'google');
+        }
+        catch (err) {
+            logger.error({ err }, 'Post-login sync failed');
+        }
+        const responseHtml = `
+            <html>
+            <head><meta name="viewport" content="width=device-width, initial-scale=1" /></head>
+            <body>
+            <h1>Authentication Successful</h1>
+            <p>Database synced. Returning to dango...</p>
+            <p><a href="/?google_auth=success">Tap here if you are not redirected</a></p>
+            <script>
+            (function () {
+              var payload = { type: 'GOOGLE_AUTH_SUCCESS', user: ${JSON.stringify(user)} };
+              try {
+                if (window.opener && !window.opener.closed) {
+                  window.opener.postMessage(payload, window.location.origin);
+                  try {
+                    window.opener.postMessage(payload, 'http://localhost:${CONFIG.PORT}');
+                  } catch (e) {}
+                  try {
+                    window.opener.postMessage(payload, 'http://127.0.0.1:${CONFIG.PORT}');
+                  } catch (e) {}
+                  setTimeout(function () { window.close(); }, 300);
+                  setTimeout(function () { window.location.href = '/?google_auth=success'; }, 1500);
+                } else {
+                  window.location.href = '/?google_auth=success';
+                }
+              } catch (e) {
+                window.location.href = '/?google_auth=success';
+              }
+            })();
+            </script>
+            </body>
+            </html>
+            `;
+        return c.html(responseHtml);
+    });
+}