@itsmrtr/bunkoshelf 1.6.0 → 1.7.1

package/dist/src/components/ui/MangaCard.tsx

@@ -4,6 +4,8 @@ import Link from "next/link";
 import Image from "next/image";
 import clsx from "clsx";
 import { useRef } from "react";
+import { CloudIcon } from "lucide-react";
+import { usePwa } from "@/components/pwa/PwaProvider";
 import type { DictionarySection } from "@/lib/types";
 
 interface MangaCardProps {
@@ -20,6 +22,8 @@ interface MangaCardProps {
   className?: string;
   seriesSlug?: string | null;
   progressRatio?: number | null;
+  offlineVolumeId?: string | null;
+  offlineSeriesId?: string | null;
 }
 
 export default function MangaCard({
@@ -36,13 +40,23 @@ export default function MangaCard({
   className,
   seriesSlug,
   progressRatio,
+  offlineVolumeId,
+  offlineSeriesId,
 }: MangaCardProps) {
   const t = intl;
   const ratio = progressRatio ?? 0;
   const touchStart = useRef<{ x: number; y: number } | null>(null);
   const hasTouchMoved = useRef(false);
+  const { offlineSlugs, offlineVolumeIds, offlineSeriesIds } = usePwa();
 
   const manga = t.manga as DictionarySection;
+  const volumeSlug = href.split("?")[0].split("/").pop();
+  const isOfflineCover = cover?.startsWith("/offline/") ?? false;
+  const isOfflineAvailable = isSeries
+    ? !!offlineSeriesId && offlineSeriesIds.has(offlineSeriesId)
+    : !!offlineVolumeId && offlineVolumeIds.has(offlineVolumeId)
+      ? true
+      : !!volumeSlug && offlineSlugs.has(volumeSlug);
 
   return (
     <Link
@@ -87,13 +101,56 @@ export default function MangaCard({
       }}
     >
       <div className="relative aspect-[7/10.5] w-full flex-shrink-0">
-        <Image
-          src={cover || "/placeholder.svg?=v1"}
-          alt={`Cover for ${title ?? ""}`}
-          fill
-          sizes="(max-width: 768px) 50vw, (max-width: 1280px) 20vw, 14vw"
-          className="object-cover z-0"
-        />
+        {isOfflineCover ? (
+          // IndexedDB pages are served by the service worker and cannot use Next's image optimizer.
+          // eslint-disable-next-line @next/next/no-img-element
+          <img
+            src={cover ?? undefined}
+            alt={`Cover for ${title ?? ""}`}
+            className="absolute inset-0 h-full w-full object-cover z-0"
+          />
+        ) : (
+          <Image
+            src={cover || "/placeholder.svg?=v1"}
+            alt={`Cover for ${title ?? ""}`}
+            fill
+            sizes="(max-width: 768px) 50vw, (max-width: 1280px) 20vw, 14vw"
+            className="object-cover z-0"
+          />
+        )}
+
+        <div className="absolute top-2 right-2 z-10 flex items-center gap-1">
+          {isSeries && volumeCount != null && (
+            <span className="bg-neutral-700 text-[10px] leading-none uppercase py-1 px-1.5 rounded">
+              {volumeCount} {manga.volumes as string}
+            </span>
+          )}
+          {isSeries && onGoing && (
+            <span className="bg-cyan-500 text-white text-[10px] leading-none uppercase py-1 px-1.5 rounded">
+              {manga.onGoing as string}
+            </span>
+          )}
+          {isSeries && onPause && (
+            <span className="bg-yellow-500 text-onix text-[10px] leading-none uppercase py-1 px-1.5 rounded">
+              {manga.hiatus as string}
+            </span>
+          )}
+          {isSeries && isOfflineAvailable && (
+            <span className="bg-neutral-700 p-1 rounded" title="Offline">
+              <CloudIcon size={12} />
+            </span>
+          )}
+          {!isSeries && isOneshot && (
+            <span className="bg-neutral-700 text-[10px] leading-none uppercase py-1 px-1.5 rounded">
+              Oneshot
+            </span>
+          )}
+          {!isSeries && isOfflineAvailable && (
+            <span className="bg-neutral-700 p-1 rounded" title="Offline">
+              <CloudIcon size={12} />
+            </span>
+          )}
+        </div>
 
         {ratio > 0 && (
           <div className="absolute bottom-0 left-0 w-full h-1.5 bg-blackamber/50">
@@ -105,40 +162,16 @@ export default function MangaCard({
         )}
       </div>
 
-      <div className="flex flex-col justify-between p-3 h-24 rounded-b-lg border border-blackamber bg-onix group-hover:bg-blackamber">
+      <div className="flex items-center p-2.5 h-14 rounded-b-lg border border-blackamber bg-onix group-hover:bg-blackamber">
         <h3
+          title={title ?? ""}
           className={clsx(
-            "line-clamp-3 group-hover:text-lilah transition-all duration-300",
+            "min-w-0 w-full truncate group-hover:text-lilah transition-all duration-300",
             className
           )}
         >
           {title}
         </h3>
-
-        <div className="relative flex items-end justify-between gap-1">
-          {isSeries && volumeCount != null && (
-            <>
-              <p className="mt-2 text-xs uppercase text-neutral-500">
-                {volumeCount} {manga.volumes as string}
-              </p>
-              {onGoing && (
-                <span className="bg-cyan-500 text-white text-xs uppercase py-0.5 px-1 rounded">
-                  {manga.onGoing as string}
-                </span>
-              )}
-              {onPause && (
-                <span className="bg-yellow-500 text-onix text-xs uppercase py-0.5 px-1 rounded">
-                  {manga.hiatus as string}
-                </span>
-              )}
-            </>
-          )}
-          {isOneshot && (
-            <span className="bg-lilah text-xs uppercase py-0.5 px-1 rounded">
-              Oneshot
-            </span>
-          )}
-        </div>
       </div>
     </Link>
   );

package/dist/src/components/ui/Pagination.tsx

@@ -3,6 +3,7 @@
 import { useTransition } from "react";
 import { ChevronLeftIcon, ChevronRightIcon } from "lucide-react";
 import { usePathname, useRouter, useSearchParams } from "next/navigation";
+import { usePwa } from "@/components/pwa/PwaProvider";
 import type { DictionarySection } from "@/lib/types";
 
 interface PaginationProps {
@@ -20,6 +21,7 @@ export default function Pagination({
   const pathname = usePathname();
   const searchParams = useSearchParams();
   const [isPending, startTransition] = useTransition();
+  const { online } = usePwa();
 
   const goToPage = (page: number) => {
     if (isPending || page === currentPage || page < 1 || page > totalPages) {
@@ -30,9 +32,13 @@ export default function Pagination({
     params.set("page", String(page));
     const href = `${pathname}?${params.toString()}`;
 
-    startTransition(() => {
-      router.replace(href);
-    });
+    if (!online) {
+      window.history.replaceState({}, "", href);
+      window.dispatchEvent(new Event("bunko:offline-navigate"));
+      return;
+    }
+
+    startTransition(() => router.replace(href));
   };
 
   return (

package/dist/src/lib/auth/verifySession.ts

@@ -27,7 +27,7 @@ export async function verifySession(): Promise<Session | null> {
     const token = cookiesInstance.get("yomimono_key")?.value;
     if (!token) return null;
 
-    return resolveSession(token);
+    return await resolveSession(token);
   } catch (error) {
     if (error && typeof error === "object" && "digest" in error) {
       throw error;

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

@@ -0,0 +1,430 @@
+"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;
+  seriesStatus?: 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;
+    status?: string;
+  };
+  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,
+    seriesStatus: manifest.series.status,
+    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/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;
 }