@itsmrtr/bunkoshelf 1.5.0 → 1.7.0

package/dist/src/lib/client/offlineLibrary.ts

@@ -0,0 +1,427 @@
+"use client";
+
+import type { LibrarySection } from "@/lib/librarySection";
+
+const DB_NAME = "bunko-pwa";
+const DB_VERSION = 1;
+const VOLUMES = "volumes";
+const PAGES = "pages";
+const DOWNLOADS = "downloads";
+const OPERATIONS = "operations";
+
+export type OfflineDownloadStatus = "queued" | "downloading" | "ready" | "error";
+export type OfflineOperationKind = "favorite" | "read" | "progress" | "series-favorite";
+
+export interface OfflineVolume {
+  id: string;
+  userId: string;
+  slug: string;
+  section: LibrarySection;
+  title: string;
+  seriesId: string;
+  seriesSlug: string;
+  seriesTitle: string;
+  isOneshot: boolean;
+  mangaStyle: string | null;
+  metadata: Record<string, unknown>;
+  coverUrl: string | null;
+  downloadedAt?: string;
+  isRead: boolean;
+  isFavorite: boolean;
+  lastPage: number;
+  totalPages: number;
+}
+
+export interface OfflineDownload {
+  key: string;
+  userId: string;
+  volumeId: string;
+  status: OfflineDownloadStatus;
+  completedPages: number;
+  totalPages: number;
+  size: number;
+  error?: string;
+  updatedAt: string;
+}
+
+interface OfflinePage {
+  key: string;
+  userId: string;
+  volumeId: string;
+  index: number;
+  blob: Blob;
+}
+
+export interface OfflineOperation {
+  id: string;
+  userId: string;
+  kind: OfflineOperationKind;
+  payload: Record<string, unknown>;
+  createdAt: string;
+}
+
+interface OfflineVolumeManifest {
+  id: string;
+  slug: string;
+  section: LibrarySection;
+  title: string;
+  series: {
+    id: string;
+    slug: string;
+    title: string;
+    isOneshot: boolean;
+  };
+  mangaStyle: string | null;
+  metadata: Record<string, unknown>;
+  coverUrl: string | null;
+  isRead: boolean;
+  isFavorite: boolean;
+  lastPage: number;
+  totalPages: number;
+}
+
+function request<T>(req: IDBRequest<T>) {
+  return new Promise<T>((resolve, reject) => {
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+
+function transactionDone(tx: IDBTransaction) {
+  return new Promise<void>((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+    tx.onabort = () => reject(tx.error);
+  });
+}
+
+function volumeKey(userId: string, volumeId: string) {
+  return `${userId}:${volumeId}`;
+}
+
+function pageKey(userId: string, volumeId: string, index: number) {
+  return `${userId}:${volumeId}:${index}`;
+}
+
+function downloadKey(userId: string, volumeId: string) {
+  return `${userId}:${volumeId}`;
+}
+
+function emitChange() {
+  window.dispatchEvent(new Event("bunko:offline-change"));
+}
+
+export function offlinePageUrl(userId: string, volumeId: string, index: number) {
+  return `/offline/volumes/${encodeURIComponent(userId)}/${encodeURIComponent(volumeId)}/pages/${index}`;
+}
+
+export function openOfflineLibrary() {
+  return new Promise<IDBDatabase>((resolve, reject) => {
+    const req = indexedDB.open(DB_NAME, DB_VERSION);
+
+    req.onupgradeneeded = () => {
+      const db = req.result;
+      if (!db.objectStoreNames.contains(VOLUMES)) {
+        const store = db.createObjectStore(VOLUMES, { keyPath: "key" });
+        store.createIndex("userId", "userId", { unique: false });
+        store.createIndex("userSection", ["userId", "section"], { unique: false });
+      }
+      if (!db.objectStoreNames.contains(PAGES)) {
+        const store = db.createObjectStore(PAGES, { keyPath: "key" });
+        store.createIndex("volume", ["userId", "volumeId"], { unique: false });
+      }
+      if (!db.objectStoreNames.contains(DOWNLOADS)) {
+        const store = db.createObjectStore(DOWNLOADS, { keyPath: "key" });
+        store.createIndex("userId", "userId", { unique: false });
+      }
+      if (!db.objectStoreNames.contains(OPERATIONS)) {
+        const store = db.createObjectStore(OPERATIONS, { keyPath: "id" });
+        store.createIndex("userId", "userId", { unique: false });
+      }
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+
+export async function getOfflineVolume(userId: string, volumeId: string) {
+  const db = await openOfflineLibrary();
+  const tx = db.transaction(VOLUMES, "readonly");
+  const value = await request<(OfflineVolume & { key: string }) | undefined>(
+    tx.objectStore(VOLUMES).get(volumeKey(userId, volumeId)),
+  );
+  db.close();
+  return value ? withoutKey(value) : null;
+}
+
+export async function getReadyVolumes(userId: string, section?: LibrarySection) {
+  const db = await openOfflineLibrary();
+  const tx = db.transaction([VOLUMES, DOWNLOADS], "readonly");
+  const [volumes, downloads] = await Promise.all([
+    request<Array<OfflineVolume & { key: string }>>(
+    section
+      ? tx.objectStore(VOLUMES).index("userSection").getAll([userId, section])
+      : tx.objectStore(VOLUMES).index("userId").getAll(userId),
+    ),
+    request<OfflineDownload[]>(tx.objectStore(DOWNLOADS).index("userId").getAll(userId)),
+  ]);
+  db.close();
+  const readyIds = new Set(downloads.filter((download) => download.status === "ready").map((download) => download.volumeId));
+  const ready = volumes.filter((volume) => readyIds.has(volume.id)).map(withoutKey);
+  return ready.sort((a, b) => a.title.localeCompare(b.title));
+}
+
+export async function getDownload(userId: string, volumeId: string) {
+  const db = await openOfflineLibrary();
+  const tx = db.transaction(DOWNLOADS, "readonly");
+  const value = await request<OfflineDownload | undefined>(tx.objectStore(DOWNLOADS).get(downloadKey(userId, volumeId)));
+  db.close();
+  return value ?? null;
+}
+
+export async function getOfflineImages(userId: string, volumeId: string) {
+  const download = await getDownload(userId, volumeId);
+  if (download?.status !== "ready") return [];
+  return Array.from({ length: download.totalPages }, (_, index) => offlinePageUrl(userId, volumeId, index));
+}
+
+async function putDownload(download: OfflineDownload) {
+  const db = await openOfflineLibrary();
+  const tx = db.transaction(DOWNLOADS, "readwrite");
+  tx.objectStore(DOWNLOADS).put(download);
+  await transactionDone(tx);
+  db.close();
+  emitChange();
+}
+
+async function saveManifest(userId: string, manifest: OfflineVolumeManifest) {
+  const db = await openOfflineLibrary();
+  const tx = db.transaction(VOLUMES, "readwrite");
+  tx.objectStore(VOLUMES).put({
+    key: volumeKey(userId, manifest.id),
+    userId,
+    id: manifest.id,
+    slug: manifest.slug,
+    section: manifest.section,
+    title: manifest.title,
+    seriesId: manifest.series.id,
+    seriesSlug: manifest.series.slug,
+    seriesTitle: manifest.series.title,
+    isOneshot: manifest.series.isOneshot,
+    mangaStyle: manifest.mangaStyle,
+    metadata: manifest.metadata,
+    coverUrl: manifest.coverUrl,
+    isRead: manifest.isRead,
+    isFavorite: manifest.isFavorite,
+    lastPage: manifest.lastPage,
+    totalPages: manifest.totalPages,
+  });
+  await transactionDone(tx);
+  db.close();
+}
+
+async function hasPage(userId: string, volumeId: string, index: number) {
+  const db = await openOfflineLibrary();
+  const tx = db.transaction(PAGES, "readonly");
+  const value = await request<OfflinePage | undefined>(tx.objectStore(PAGES).get(pageKey(userId, volumeId, index)));
+  db.close();
+  return !!value;
+}
+
+async function savePage(userId: string, volumeId: string, index: number, blob: Blob) {
+  const db = await openOfflineLibrary();
+  const tx = db.transaction(PAGES, "readwrite");
+  tx.objectStore(PAGES).put({ key: pageKey(userId, volumeId, index), userId, volumeId, index, blob } satisfies OfflinePage);
+  await transactionDone(tx);
+  db.close();
+}
+
+async function fetchManifest(section: LibrarySection, kind: "volume" | "series", slug: string) {
+  const response = await fetch(`/api/offline/library/${section}/${kind}/${encodeURIComponent(slug)}`);
+  if (!response.ok) throw new Error("No se pudo preparar la descarga offline");
+  return response.json() as Promise<{ volume?: OfflineVolumeManifest; volumes?: OfflineVolumeManifest[] }>;
+}
+
+async function fetchBlob(url: string) {
+  const response = await fetch(url);
+  if (!response.ok) throw new Error("No se pudo descargar una página");
+  return response.blob();
+}
+
+export async function downloadOfflineVolume(
+  userId: string,
+  manifest: OfflineVolumeManifest,
+  onProgress?: (download: OfflineDownload) => void,
+) {
+  if (!navigator.onLine) throw new Error("Se requiere conexión para descargar");
+  await navigator.storage?.persist?.();
+  await saveManifest(userId, manifest);
+
+  const pagesResponse = await fetch("/api/reader/manga", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ slug: manifest.slug }),
+  });
+  const pagesData = await pagesResponse.json() as { images?: string[] };
+  if (!pagesResponse.ok || !pagesData.images?.length) throw new Error("No se encontraron páginas para descargar");
+
+  let size = 0;
+  let completedPages = 0;
+  const totalPages = pagesData.images.length;
+  const publish = async (status: OfflineDownloadStatus, error?: string) => {
+    const download: OfflineDownload = {
+      key: downloadKey(userId, manifest.id), userId, volumeId: manifest.id, status,
+      completedPages, totalPages, size, error, updatedAt: new Date().toISOString(),
+    };
+    await putDownload(download);
+    onProgress?.(download);
+    return download;
+  };
+
+  try {
+    await publish("queued");
+    if (manifest.coverUrl && !(await hasPage(userId, manifest.id, -1))) {
+      const cover = await fetchBlob(manifest.coverUrl);
+      await savePage(userId, manifest.id, -1, cover);
+      size += cover.size;
+    }
+
+    for (let index = 0; index < pagesData.images.length; index++) {
+      if (await hasPage(userId, manifest.id, index)) {
+        completedPages++;
+        continue;
+      }
+      await publish("downloading");
+      const blob = await fetchBlob(pagesData.images[index]);
+      await savePage(userId, manifest.id, index, blob);
+      size += blob.size;
+      completedPages++;
+      await publish("downloading");
+    }
+
+    const ready = await publish("ready");
+    const db = await openOfflineLibrary();
+    const tx = db.transaction(VOLUMES, "readwrite");
+    const stored = await request<(OfflineVolume & { key: string }) | undefined>(tx.objectStore(VOLUMES).get(volumeKey(userId, manifest.id)));
+    if (stored) tx.objectStore(VOLUMES).put({ ...stored, downloadedAt: new Date().toISOString(), totalPages: totalPages });
+    await transactionDone(tx);
+    db.close();
+    emitChange();
+    return ready;
+  } catch (error) {
+    await publish("error", error instanceof Error ? error.message : "Error al descargar");
+    throw error;
+  }
+}
+
+export async function downloadVolumeBySlug(userId: string, section: LibrarySection, slug: string, onProgress?: (download: OfflineDownload) => void) {
+  const data = await fetchManifest(section, "volume", slug);
+  if (!data.volume) throw new Error("Tomo no encontrado");
+  return downloadOfflineVolume(userId, data.volume, onProgress);
+}
+
+export async function downloadSeriesBySlug(userId: string, section: LibrarySection, slug: string, onProgress?: (completed: number, total: number) => void) {
+  const data = await fetchManifest(section, "series", slug);
+  const volumes = data.volumes ?? [];
+  if (!volumes.length) throw new Error("La serie no tiene tomos descargables");
+  let completed = 0;
+  for (const volume of volumes) {
+    await downloadOfflineVolume(userId, volume);
+    completed++;
+    onProgress?.(completed, volumes.length);
+  }
+}
+
+export async function removeOfflineVolume(userId: string, volumeId: string) {
+  const db = await openOfflineLibrary();
+  const pageTx = db.transaction(PAGES, "readwrite");
+  const keys = await request<IDBValidKey[]>(pageTx.objectStore(PAGES).index("volume").getAllKeys([userId, volumeId]));
+  keys.forEach((key) => pageTx.objectStore(PAGES).delete(key));
+  await transactionDone(pageTx);
+  const tx = db.transaction([VOLUMES, DOWNLOADS], "readwrite");
+  tx.objectStore(VOLUMES).delete(volumeKey(userId, volumeId));
+  tx.objectStore(DOWNLOADS).delete(downloadKey(userId, volumeId));
+  await transactionDone(tx);
+  db.close();
+  emitChange();
+}
+
+export async function removeOfflineSeries(userId: string, seriesId: string) {
+  const db = await openOfflineLibrary();
+  const tx = db.transaction(VOLUMES, "readonly");
+  const volumes = await request<Array<OfflineVolume & { key: string }>>(tx.objectStore(VOLUMES).index("userId").getAll(userId));
+  db.close();
+  await Promise.all(volumes.filter((volume) => volume.seriesId === seriesId).map((volume) => removeOfflineVolume(userId, volume.id)));
+}
+
+export async function updateOfflineVolume(userId: string, volumeId: string, update: Partial<Pick<OfflineVolume, "isRead" | "isFavorite" | "lastPage" | "totalPages">>) {
+  const db = await openOfflineLibrary();
+  const tx = db.transaction(VOLUMES, "readwrite");
+  const stored = await request<(OfflineVolume & { key: string }) | undefined>(tx.objectStore(VOLUMES).get(volumeKey(userId, volumeId)));
+  if (stored) tx.objectStore(VOLUMES).put({ ...stored, ...update });
+  await transactionDone(tx);
+  db.close();
+  emitChange();
+}
+
+export async function enqueueOfflineOperation(userId: string, kind: OfflineOperationKind, payload: Record<string, unknown>) {
+  const db = await openOfflineLibrary();
+  const tx = db.transaction(OPERATIONS, "readwrite");
+  const id = crypto.randomUUID();
+  tx.objectStore(OPERATIONS).put({ id, userId, kind, payload, createdAt: new Date().toISOString() } satisfies OfflineOperation);
+  await transactionDone(tx);
+  db.close();
+  emitChange();
+}
+
+export async function flushOfflineOperations(userId: string) {
+  if (!navigator.onLine) return;
+  const db = await openOfflineLibrary();
+  const tx = db.transaction(OPERATIONS, "readonly");
+  const operations = await request<OfflineOperation[]>(tx.objectStore(OPERATIONS).index("userId").getAll(userId));
+  db.close();
+  if (!operations.length) return;
+  const response = await fetch("/api/offline/sync", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ operations }),
+  });
+  if (!response.ok) return;
+  const data = await response.json() as { completed?: string[] };
+  if (!data.completed?.length) return;
+  const writable = await openOfflineLibrary();
+  const writableTx = writable.transaction(OPERATIONS, "readwrite");
+  data.completed.forEach((id) => writableTx.objectStore(OPERATIONS).delete(id));
+  await transactionDone(writableTx);
+  writable.close();
+  emitChange();
+}
+
+export async function resumeOfflineDownloads(userId: string) {
+  if (!navigator.onLine) return;
+  const db = await openOfflineLibrary();
+  const tx = db.transaction([DOWNLOADS, VOLUMES], "readonly");
+  const downloads = await request<OfflineDownload[]>(tx.objectStore(DOWNLOADS).index("userId").getAll(userId));
+  const storedVolumes = await request<Array<OfflineVolume & { key: string }>>(tx.objectStore(VOLUMES).index("userId").getAll(userId));
+  const pending = downloads.filter((download) => download.status === "downloading" || download.status === "queued" || download.status === "error");
+  const manifests: OfflineVolumeManifest[] = [];
+  for (const download of pending) {
+    const volume = storedVolumes.find((item) => item.id === download.volumeId);
+    if (!volume) continue;
+    manifests.push({
+      id: volume.id, slug: volume.slug, section: volume.section, title: volume.title,
+      series: { id: volume.seriesId, slug: volume.seriesSlug, title: volume.seriesTitle, isOneshot: volume.isOneshot },
+      mangaStyle: volume.mangaStyle, metadata: volume.metadata, coverUrl: volume.coverUrl,
+      isRead: volume.isRead, isFavorite: volume.isFavorite, lastPage: volume.lastPage, totalPages: volume.totalPages,
+    });
+  }
+  db.close();
+  for (const manifest of manifests) {
+    try { await downloadOfflineVolume(userId, manifest); } catch { /* retry on next connection */ }
+  }
+}
+
+function withoutKey(value: OfflineVolume & { key: string }): OfflineVolume {
+  const { key: _key, ...volume } = value;
+  return volume;
+}

package/dist/src/lib/db/library.ts

@@ -479,7 +479,14 @@ function buildVolumeFilterSql(
   if (options.authorNames && options.authorNames.length > 0) {
     params.push(options.authorNames);
     conditions.push(`
-      COALESCE(NULLIF(BTRIM(vm.writer), ''), '__unknown__') = ANY($${params.length}::text[])
+      EXISTS (
+        SELECT 1
+        FROM regexp_split_to_table(
+          COALESCE(NULLIF(BTRIM(vm.writer), ''), '__unknown__'),
+          ','
+        ) AS split_author(value)
+        WHERE BTRIM(split_author.value) = ANY($${params.length}::text[])
+      )
     `);
   }
 
@@ -679,10 +686,18 @@ export async function listPagedCatalogAuthors(
       `
         SELECT COUNT(*) AS total
         FROM (
-          SELECT COALESCE(NULLIF(BTRIM(vm.writer), ''), '__unknown__') AS author
+          SELECT author.name
           FROM manga_volumes mv
           LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
-          GROUP BY COALESCE(NULLIF(BTRIM(vm.writer), ''), '__unknown__')
+          CROSS JOIN LATERAL (
+            SELECT DISTINCT BTRIM(split_author.value) AS name
+            FROM regexp_split_to_table(
+              COALESCE(NULLIF(BTRIM(vm.writer), ''), '__unknown__'),
+              ','
+            ) AS split_author(value)
+            WHERE BTRIM(split_author.value) <> ''
+          ) AS author
+          GROUP BY author.name
         ) AS authors
       `
     ),
@@ -704,7 +719,7 @@ export async function listPagedCatalogAuthors(
           grouped.has_others
         FROM (
           SELECT
-            COALESCE(NULLIF(BTRIM(vm.writer), ''), '__unknown__') AS author,
+            author.name AS author,
             COUNT(mv.id) AS works,
             ROUND(AVG(utv.personal_rating)::numeric, 1)::float8 AS avg_rating,
             COUNT(*) FILTER (WHERE utv.is_read = TRUE) AS read_count,
@@ -712,10 +727,18 @@ export async function listPagedCatalogAuthors(
             BOOL_OR(vm.manga_style = 'No') AS has_others
           FROM manga_volumes mv
           LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
+          CROSS JOIN LATERAL (
+            SELECT DISTINCT BTRIM(split_author.value) AS name
+            FROM regexp_split_to_table(
+              COALESCE(NULLIF(BTRIM(vm.writer), ''), '__unknown__'),
+              ','
+            ) AS split_author(value)
+            WHERE BTRIM(split_author.value) <> ''
+          ) AS author
           LEFT JOIN user_to_volumes utv
             ON utv.volume_id = mv.id
            AND utv.user_id = $1
-          GROUP BY COALESCE(NULLIF(BTRIM(vm.writer), ''), '__unknown__')
+          GROUP BY author.name
         ) AS grouped
         ORDER BY grouped.author ASC
         LIMIT $2
@@ -874,10 +897,18 @@ async function listLibraryFiltersRaw(scope?: LibraryScope): Promise<{
     query<AuthorFilter>(
       `
         SELECT DISTINCT
-          COALESCE(NULLIF(BTRIM(vm.writer), ''), '__unknown__') AS id,
-          COALESCE(NULLIF(BTRIM(vm.writer), ''), '__unknown__') AS name
+          author.name AS id,
+          author.name
         FROM manga_volumes mv
         LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
+        CROSS JOIN LATERAL (
+          SELECT DISTINCT BTRIM(split_author.value) AS name
+          FROM regexp_split_to_table(
+            COALESCE(NULLIF(BTRIM(vm.writer), ''), '__unknown__'),
+            ','
+          ) AS split_author(value)
+          WHERE BTRIM(split_author.value) <> ''
+        ) AS author
         ${authorScopeWhere}
         ORDER BY name ASC
       `,

package/dist/src/lib/db/migrations/004_offline_sync_operations.sql

@@ -0,0 +1,10 @@
+CREATE TABLE IF NOT EXISTS offline_sync_operations (
+  id TEXT PRIMARY KEY,
+  user_id TEXT NOT NULL,
+  client_operation_id TEXT NOT NULL,
+  created_at TIMESTAMP NOT NULL DEFAULT NOW(),
+  UNIQUE (user_id, client_operation_id)
+);
+
+CREATE INDEX IF NOT EXISTS offline_sync_operations_user_id_idx
+  ON offline_sync_operations (user_id);

package/dist/src/lib/db/pool.ts

@@ -8,11 +8,13 @@ pg.types.setTypeParser(1700, (value: string) =>
   value !== null ? parseFloat(value) : null
 );
 
-let pool: pg.Pool | undefined;
+const globalForPool = globalThis as typeof globalThis & {
+  bunkoPool?: pg.Pool;
+};
 
 export function getPool(): pg.Pool {
-  if (pool) {
-    return pool;
+  if (globalForPool.bunkoPool) {
+    return globalForPool.bunkoPool;
   }
 
   const connectionString = process.env.DATABASE_URL;
@@ -21,17 +23,17 @@ export function getPool(): pg.Pool {
     throw new Error("DATABASE_URL is not defined in environment variables");
   }
 
-  pool = new pg.Pool({
+  const pool = new pg.Pool({
     connectionString,
     max: 10,
     idleTimeoutMillis: 30000,
-    connectionTimeoutMillis: 2000,
+    connectionTimeoutMillis: 10000,
   });
 
   pool.on("error", (error: Error) => {
     console.error("[bunko/db] Unexpected pool error:", error.message);
-    process.exit(1);
   });
 
+  globalForPool.bunkoPool = pool;
   return pool;
 }

package/dist/src/lib/db/query.ts

@@ -1,12 +1,43 @@
-import type { QueryResultRow } from "pg";
+import type { QueryResult, QueryResultRow } from "pg";
 import { getPool } from "./pool";
 
+function isRetryableConnectionError(error: unknown): boolean {
+  if (!(error instanceof Error)) return false;
+
+  const message = error.message.toLowerCase();
+  return (
+    message.includes("connection terminated due to connection timeout") ||
+    message.includes("timeout exceeded when trying to connect") ||
+    message.includes("connect econnrefused") ||
+    message.includes("the database system is starting up")
+  );
+}
+
+function wait(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function runQuery<T extends QueryResultRow>(
+  text: string,
+  params: unknown[]
+): Promise<QueryResult<T>> {
+  const pool = getPool();
+
+  try {
+    return await pool.query<T>(text, params);
+  } catch (error) {
+    if (!isRetryableConnectionError(error)) throw error;
+
+    await wait(150);
+    return pool.query<T>(text, params);
+  }
+}
+
 export async function query<T extends QueryResultRow>(
   text: string,
   params: unknown[] = []
 ): Promise<T[]> {
-  const pool = getPool();
-  const result = await pool.query<T>(text, params);
+  const result = await runQuery<T>(text, params);
   return result.rows;
 }
 
@@ -22,7 +53,6 @@ export async function execute(
   text: string,
   params: unknown[] = []
 ): Promise<number> {
-  const pool = getPool();
-  const result = await pool.query(text, params);
+  const result = await runQuery(text, params);
   return result.rowCount ?? 0;
 }

package/dist/src/lib/i18n/dictionaries/en/misc.json

@@ -1,6 +1,16 @@
 {
   "misc": {
     "coming": "Feature coming soon",
+    "offline": {
+      "unavailable": "Unavailable offline",
+      "download": "Download for offline reading",
+      "remove": "Remove offline download",
+      "downloadSeries": "Do you want to download every volume in this series?",
+      "removeSeries": "Do you want to remove this series downloads?",
+      "removeVolume": "Do you want to remove this volume download?",
+      "downloading": "Downloading for offline reading",
+      "downloadError": "The download could not be completed"
+    },
     "noSeriesFav": "There are no favorite series...",
     "noVolumesFav": "There is no favorite manga...",
     "dropzoneTt": "Drag and drop files here or click to select",

package/dist/src/lib/i18n/dictionaries/es/misc.json

@@ -1,6 +1,16 @@
 {
   "misc": {
     "coming": "Característica disponible próximamente",
+    "offline": {
+      "unavailable": "No disponible sin conexión",
+      "download": "Descargar para leer sin conexión",
+      "remove": "Eliminar descarga offline",
+      "downloadSeries": "¿Quieres descargar todos los tomos de esta serie?",
+      "removeSeries": "¿Quieres eliminar las descargas de esta serie?",
+      "removeVolume": "¿Quieres eliminar la descarga de este tomo?",
+      "downloading": "Descargando para leer sin conexión",
+      "downloadError": "No se pudo completar la descarga"
+    },
     "noSeriesFav": "No hay series favoritas...",
     "noVolumesFav": "No hay ningún manga favorito...",
     "dropzoneTt": "Arrastra y suelta aquí o haz clic para seleccionar",

package/dist/src/lib/uploadIndexer.ts

@@ -47,12 +47,13 @@ export async function indexUploadedVolume({
 }: IndexUploadParams) {
   const cleanTitle = dirName.replace(/\[oneshot\]/gi, "").trim();
   const seriesSlug = toSlug(cleanTitle);
+  const resolvedIsOneshot = isOneshot || /\[oneshot\]/i.test(dirName);
 
   const mangaSeries = await upsertSeriesRecord({
     slug: seriesSlug,
     title: cleanTitle,
     path: seriesPath,
-    isOneshot: !!isOneshot,
+    isOneshot: resolvedIsOneshot,
     mtime: new Date(),
   });
 

package/dist/src/lib/utils.ts

@@ -70,6 +70,7 @@ function isTransientDatabaseConnectionError(error: unknown): boolean {
   const message = error.message.toLowerCase();
 
   return (
+    message.includes("connection terminated due to connection timeout") ||
     message.includes("timeout exceeded when trying to connect") ||
     message.includes("connect econnrefused") ||
     message.includes("the database system is starting up")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itsmrtr/bunkoshelf",
-  "version": "1.5.0",
+  "version": "1.7.0",
   "description": "Self-hosted personal manga library.",
   "keywords": [
     "bunko",