@itsmrtr/bunkoshelf 1.3.2 → 1.4.1

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

@@ -1,5 +1,9 @@
 import { cacheLife, cacheTag } from "next/cache";
-import type { LibraryScope } from "@/lib/librarySection";
+import {
+  getLibrarySection,
+  type LibraryScope,
+  type LibrarySection,
+} from "@/lib/librarySection";
 import { MANGA_LIBRARY_TAG } from "@/lib/mangaLibraryCache";
 import { query, queryOne } from "./query";
 
@@ -167,6 +171,41 @@ export interface PaginatedResult<T> {
   totalPages: number;
 }
 
+export interface CatalogLibraryVolume {
+  id: string;
+  slug: string;
+  section: LibrarySection;
+  title: string | null;
+  series: string | null;
+  number: number | null;
+  year: number | null;
+  writer: string | null;
+  publisher: string | null;
+  languageISO: string | null;
+  ageRating: string | null;
+  gtin: string | null;
+  isRead: boolean;
+  isFavorite: boolean;
+}
+
+export interface CatalogAuthorStats {
+  author: string | null;
+  works: number;
+  avgRating: number | null;
+  readCount: number;
+  hasManga: boolean;
+  hasOthers: boolean;
+  hasBooks: boolean;
+}
+
+export interface CatalogRelationStats {
+  name: string;
+  hasManga: boolean;
+  hasOthers: boolean;
+  hasBooks: boolean;
+  total: number;
+}
+
 interface VolumeRow {
   volume_id: string;
   volume_slug: string;
@@ -533,6 +572,277 @@ function parseCount(value: string | number): number {
   return typeof value === "number" ? value : Number(value);
 }
 
+export async function listPagedCatalogLibraryVolumes(
+  options?: PagedQueryOptions & { userId?: string | null }
+): Promise<PaginatedResult<CatalogLibraryVolume>> {
+  const pagination = buildPagination(options);
+
+  const [countRow, rows] = await Promise.all([
+    queryOne<{ total: string | number }>(
+      `
+        SELECT COUNT(*) AS total
+        FROM manga_volumes mv
+      `
+    ),
+    query<{
+      id: string;
+      slug: string;
+      title: string | null;
+      series: string | null;
+      number: number | null;
+      year: number | null;
+      writer: string | null;
+      publisher: string | null;
+      language_iso: string | null;
+      age_rating: string | null;
+      gtin: string | null;
+      manga_style: string | null;
+      is_read: boolean | null;
+      is_favorite: boolean | null;
+    }>(
+      `
+        SELECT
+          mv.id,
+          mv.slug,
+          vm.title,
+          ms.title AS series,
+          vm.number,
+          vm.year,
+          vm.writer,
+          vm.publisher,
+          vm.language_iso,
+          vm.age_rating,
+          vm.gtin,
+          vm.manga_style,
+          utv.is_read,
+          utv.is_favorite
+        FROM manga_volumes mv
+        INNER JOIN manga_series ms ON ms.id = mv.series_id
+        LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
+        LEFT JOIN user_to_volumes utv
+          ON utv.volume_id = mv.id
+         AND utv.user_id = $1
+        ORDER BY ms.sort_title ASC, mv.sort_title ASC, mv.id ASC
+        LIMIT $2
+        OFFSET $3
+      `,
+      [options?.userId ?? null, pagination.pageSize, pagination.offset]
+    ),
+  ]);
+
+  const total = parseCount(countRow?.total ?? 0);
+
+  return mapPaginatedResult(
+    rows.map((row) => ({
+      id: row.id,
+      slug: row.slug,
+      section: getLibrarySection(row.manga_style),
+      title: row.title,
+      series: row.series,
+      number: row.number,
+      year: row.year,
+      writer: row.writer,
+      publisher: row.publisher,
+      languageISO: row.language_iso,
+      ageRating: row.age_rating,
+      gtin: row.gtin,
+      isRead: row.is_read === true,
+      isFavorite: row.is_favorite === true,
+    })),
+    total,
+    pagination
+  );
+}
+
+export async function listPagedCatalogAuthors(
+  options?: PagedQueryOptions & { userId?: string | null }
+): Promise<PaginatedResult<CatalogAuthorStats>> {
+  const pagination = buildPagination(options);
+
+  const [countRow, rows] = await Promise.all([
+    queryOne<{ total: string | number }>(
+      `
+        SELECT COUNT(*) AS total
+        FROM (
+          SELECT COALESCE(NULLIF(BTRIM(vm.writer), ''), '__unknown__') AS author
+          FROM manga_volumes mv
+          LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
+          GROUP BY COALESCE(NULLIF(BTRIM(vm.writer), ''), '__unknown__')
+        ) AS authors
+      `
+    ),
+    query<{
+      author: string;
+      works: string | number;
+      avg_rating: number | null;
+      read_count: string | number;
+      has_manga: boolean | null;
+      has_others: boolean | null;
+    }>(
+      `
+        SELECT
+          grouped.author,
+          grouped.works,
+          grouped.avg_rating,
+          grouped.read_count,
+          grouped.has_manga,
+          grouped.has_others
+        FROM (
+          SELECT
+            COALESCE(NULLIF(BTRIM(vm.writer), ''), '__unknown__') 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,
+            BOOL_OR(vm.manga_style IS DISTINCT FROM 'No') AS has_manga,
+            BOOL_OR(vm.manga_style = 'No') AS has_others
+          FROM manga_volumes mv
+          LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
+          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__')
+        ) AS grouped
+        ORDER BY grouped.author ASC
+        LIMIT $2
+        OFFSET $3
+      `,
+      [options?.userId ?? null, pagination.pageSize, pagination.offset]
+    ),
+  ]);
+
+  const total = parseCount(countRow?.total ?? 0);
+
+  return mapPaginatedResult(
+    rows.map((row) => ({
+      author: row.author === "__unknown__" ? null : row.author,
+      works: parseCount(row.works),
+      avgRating: row.avg_rating,
+      readCount: parseCount(row.read_count),
+      hasManga: row.has_manga === true,
+      hasOthers: row.has_others === true,
+      hasBooks: false,
+    })),
+    total,
+    pagination
+  );
+}
+
+export async function listPagedCatalogGenres(
+  options?: PagedQueryOptions
+): Promise<PaginatedResult<CatalogRelationStats>> {
+  const pagination = buildPagination(options);
+
+  const [countRow, rows] = await Promise.all([
+    queryOne<{ total: string | number }>(
+      `
+        SELECT COUNT(*) AS total
+        FROM (
+          SELECT g.id
+          FROM genres g
+          INNER JOIN volume_to_genres vtg ON vtg.genre_id = g.id
+          INNER JOIN manga_volumes mv ON mv.id = vtg.volume_id
+          GROUP BY g.id
+        ) AS genres
+      `
+    ),
+    query<{
+      name: string;
+      has_manga: boolean | null;
+      has_others: boolean | null;
+      total: string | number;
+    }>(
+      `
+        SELECT
+          g.name,
+          BOOL_OR(vm.manga_style IS DISTINCT FROM 'No') AS has_manga,
+          BOOL_OR(vm.manga_style = 'No') AS has_others,
+          COUNT(mv.id) AS total
+        FROM genres g
+        INNER JOIN volume_to_genres vtg ON vtg.genre_id = g.id
+        INNER JOIN manga_volumes mv ON mv.id = vtg.volume_id
+        LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
+        GROUP BY g.id, g.name
+        ORDER BY g.name ASC
+        LIMIT $1
+        OFFSET $2
+      `,
+      [pagination.pageSize, pagination.offset]
+    ),
+  ]);
+
+  const total = parseCount(countRow?.total ?? 0);
+
+  return mapPaginatedResult(
+    rows.map((row) => ({
+      name: row.name,
+      hasManga: row.has_manga === true,
+      hasOthers: row.has_others === true,
+      hasBooks: false,
+      total: parseCount(row.total),
+    })),
+    total,
+    pagination
+  );
+}
+
+export async function listPagedCatalogTags(
+  options?: PagedQueryOptions
+): Promise<PaginatedResult<CatalogRelationStats>> {
+  const pagination = buildPagination(options);
+
+  const [countRow, rows] = await Promise.all([
+    queryOne<{ total: string | number }>(
+      `
+        SELECT COUNT(*) AS total
+        FROM (
+          SELECT t.id
+          FROM tags t
+          INNER JOIN volume_to_tags vtt ON vtt.tag_id = t.id
+          INNER JOIN manga_volumes mv ON mv.id = vtt.volume_id
+          GROUP BY t.id
+        ) AS tags
+      `
+    ),
+    query<{
+      name: string;
+      has_manga: boolean | null;
+      has_others: boolean | null;
+      total: string | number;
+    }>(
+      `
+        SELECT
+          t.name,
+          BOOL_OR(vm.manga_style IS DISTINCT FROM 'No') AS has_manga,
+          BOOL_OR(vm.manga_style = 'No') AS has_others,
+          COUNT(mv.id) AS total
+        FROM tags t
+        INNER JOIN volume_to_tags vtt ON vtt.tag_id = t.id
+        INNER JOIN manga_volumes mv ON mv.id = vtt.volume_id
+        LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
+        GROUP BY t.id, t.name
+        ORDER BY t.name ASC
+        LIMIT $1
+        OFFSET $2
+      `,
+      [pagination.pageSize, pagination.offset]
+    ),
+  ]);
+
+  const total = parseCount(countRow?.total ?? 0);
+
+  return mapPaginatedResult(
+    rows.map((row) => ({
+      name: row.name,
+      hasManga: row.has_manga === true,
+      hasOthers: row.has_others === true,
+      hasBooks: false,
+      total: parseCount(row.total),
+    })),
+    total,
+    pagination
+  );
+}
+
 async function listLibraryFiltersRaw(scope?: LibraryScope): Promise<{
   genres: GenreFilter[];
   tags: TagFilter[];

package/dist/src/lib/i18n/Dictionary.ts

@@ -20,6 +20,7 @@ const dictionaries: Record<Locale, () => Promise<Record<string, DictionarySectio
       import("./dictionaries/en/toast.json").then((m) => m.default),
       import("./dictionaries/en/search.json").then((m) => m.default),
       import("./dictionaries/en/filters.json").then((m) => m.default),
+      import("./dictionaries/en/catalog.json").then((m) => m.default),
       import("./dictionaries/en/push.json").then((m) => m.default),
       import("./dictionaries/en/months.json").then((m) => m.default),
       import("./dictionaries/en/stats.json").then((m) => m.default),
@@ -42,6 +43,7 @@ const dictionaries: Record<Locale, () => Promise<Record<string, DictionarySectio
       import("./dictionaries/es/toast.json").then((m) => m.default),
       import("./dictionaries/es/search.json").then((m) => m.default),
       import("./dictionaries/es/filters.json").then((m) => m.default),
+      import("./dictionaries/es/catalog.json").then((m) => m.default),
       import("./dictionaries/es/push.json").then((m) => m.default),
       import("./dictionaries/es/months.json").then((m) => m.default),
       import("./dictionaries/es/stats.json").then((m) => m.default),

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

@@ -0,0 +1,33 @@
+{
+  "catalog": {
+    "title": "Catalog",
+    "library": "Library",
+    "authors": "Authors",
+    "genres": "Genres",
+    "tags": "Tags",
+    "genreColumn": "Genre",
+    "tagColumn": "Tag",
+    "mangaColumn": "Manga",
+    "othersColumn": "Comic/Others",
+    "booksColumn": "Books",
+    "totalColumn": "Total",
+    "authorColumn": "Author",
+    "unknownAuthor": "Unknown",
+    "worksColumn": "Works",
+    "avgRatingColumn": "Avg",
+    "progressColumn": "Progress",
+    "libraryColumn": "Library",
+    "titleColumn": "Title",
+    "seriesColumn": "Series",
+    "numberColumn": "Number",
+    "yearColumn": "Year",
+    "writerColumn": "Writer",
+    "publisherColumn": "Publisher",
+    "statusColumn": "Stat",
+    "languageColumn": "Language",
+    "ageRatingColumn": "Age",
+    "gtinColumn": "ISBN",
+    "favoriteColumn": "Fav",
+    "actionsColumn": "Act"
+  }
+}

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

@@ -9,6 +9,8 @@
     "ttSeriesOthers": "Series - Comic/Others",
     "ttVolumesOthers": "Volumes - Comic/Others",
     "sectionManga": "Manga",
+    "badgeSeries": "Series",
+    "badgeVolumes": "Volumes",
     "sectionMangaSeries": "Manga - Series",
     "sectionMangaVolumes": "Manga - Volumes",
     "sectionOthers": "Comic/Others",

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

@@ -6,6 +6,7 @@
     "others": "Comic/Others",
     "books": "Books",
     "favorites": "Favorites",
+    "catalog": "Catalog",
     "profile": "Profile"
   }
 }

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

@@ -0,0 +1,33 @@
+{
+  "catalog": {
+    "title": "Catálogo",
+    "library": "Biblioteca",
+    "authors": "Autores",
+    "genres": "Géneros",
+    "tags": "Etiquetas",
+    "genreColumn": "Género",
+    "tagColumn": "Etiqueta",
+    "mangaColumn": "Manga",
+    "othersColumn": "Cómic/Otros",
+    "booksColumn": "Libros",
+    "totalColumn": "Total",
+    "authorColumn": "Autor",
+    "unknownAuthor": "Desconocido",
+    "worksColumn": "Obras",
+    "avgRatingColumn": "Prom",
+    "progressColumn": "Progreso",
+    "libraryColumn": "Biblioteca",
+    "titleColumn": "Título",
+    "seriesColumn": "Serie",
+    "numberColumn": "Número",
+    "yearColumn": "Año",
+    "writerColumn": "Autor",
+    "publisherColumn": "Editorial",
+    "statusColumn": "Est",
+    "languageColumn": "Idioma",
+    "ageRatingColumn": "Clasf",
+    "gtinColumn": "ISBN",
+    "favoriteColumn": "Fav",
+    "actionsColumn": "Acc"
+  }
+}

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

@@ -9,6 +9,8 @@
     "ttSeriesOthers": "Series - Cómic/Otros",
     "ttVolumesOthers": "Tomos - Cómic/Otros",
     "sectionManga": "Mangas",
+    "badgeSeries": "Series",
+    "badgeVolumes": "Tomos",
     "sectionMangaSeries": "Mangas - Series",
     "sectionMangaVolumes": "Mangas - Tomos",
     "sectionOthers": "Cómic/Otros",

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

@@ -6,6 +6,7 @@
     "others": "Cómic/Otros",
     "books": "Libros",
     "favorites": "Favoritos",
+    "catalog": "Catálogo",
     "profile": "Perfil"
   }
 }

package/dist/src/lib/nav/catalogNav.ts

@@ -0,0 +1,54 @@
+import type { LucideIcon } from "lucide-react";
+import {
+  DramaIcon,
+  LibraryBigIcon,
+  TagsIcon,
+  UserRoundPenIcon,
+} from "lucide-react";
+import type { Dictionary } from "@/lib/types";
+
+export interface CatalogNavLink {
+  label: string;
+  href: string;
+  icon: LucideIcon;
+  isActive: boolean;
+}
+
+interface GetCatalogNavLinksParams {
+  intl: Dictionary;
+  lang: string;
+  pathname: string;
+}
+
+export function getCatalogNavLinks({
+  intl,
+  lang,
+  pathname,
+}: GetCatalogNavLinksParams): CatalogNavLink[] {
+  return [
+    {
+      label: intl.catalog.library as string,
+      href: `/${lang}/catalog/library`,
+      icon: LibraryBigIcon,
+      isActive: pathname === `/${lang}/catalog/library`,
+    },
+    {
+      label: intl.catalog.authors as string,
+      href: `/${lang}/catalog/authors`,
+      icon: UserRoundPenIcon,
+      isActive: pathname === `/${lang}/catalog/authors`,
+    },
+    {
+      label: intl.catalog.genres as string,
+      href: `/${lang}/catalog/genres`,
+      icon: DramaIcon,
+      isActive: pathname === `/${lang}/catalog/genres`,
+    },
+    {
+      label: intl.catalog.tags as string,
+      href: `/${lang}/catalog/tags`,
+      icon: TagsIcon,
+      isActive: pathname === `/${lang}/catalog/tags`,
+    },
+  ];
+}

package/dist/src/lib/nav/favoritesNav.ts

@@ -0,0 +1,62 @@
+import type { LucideIcon } from "lucide-react";
+import { BookCopyIcon, BookHeartIcon, LibraryBigIcon } from "lucide-react";
+import type { Dictionary, DictionarySection } from "@/lib/types";
+
+export interface FavoritesNavLink {
+  label: string | DictionarySection;
+  href: string;
+  icon: LucideIcon;
+  isActive: boolean;
+  badge?: string;
+}
+
+interface GetFavoritesNavLinksParams {
+  intl: Dictionary;
+  lang: string;
+  pathname: string;
+}
+
+export function getFavoritesNavLinks({
+  intl,
+  lang,
+  pathname,
+}: GetFavoritesNavLinksParams): FavoritesNavLink[] {
+  const favorites = intl.favorites as DictionarySection;
+
+  return [
+    {
+      label: favorites.sectionManga,
+      href: `/${lang}/favorites/manga`,
+      icon: LibraryBigIcon,
+      isActive: pathname === `/${lang}/favorites/manga`,
+      badge: favorites.badgeSeries as string,
+    },
+    {
+      label: favorites.sectionManga,
+      href: `/${lang}/favorites/manga/volumes`,
+      icon: BookCopyIcon,
+      isActive: pathname === `/${lang}/favorites/manga/volumes`,
+      badge: favorites.badgeVolumes as string,
+    },
+    {
+      label: favorites.sectionOthers,
+      href: `/${lang}/favorites/others`,
+      icon: LibraryBigIcon,
+      isActive: pathname === `/${lang}/favorites/others`,
+      badge: favorites.badgeSeries as string,
+    },
+    {
+      label: favorites.sectionOthers,
+      href: `/${lang}/favorites/others/volumes`,
+      icon: BookCopyIcon,
+      isActive: pathname === `/${lang}/favorites/others/volumes`,
+      badge: favorites.badgeVolumes as string,
+    },
+    {
+      label: favorites.sectionBooks,
+      href: `/${lang}/favorites/books`,
+      icon: BookHeartIcon,
+      isActive: pathname === `/${lang}/favorites/books`,
+    },
+  ];
+}

package/dist/src/lib/nav/footerNav.ts

@@ -0,0 +1,78 @@
+import type { LucideIcon } from "lucide-react";
+import {
+  BookOpenIcon,
+  LanguagesIcon,
+  LogOutIcon,
+  Settings2Icon,
+} from "lucide-react";
+import type { Dictionary, Session } from "@/lib/types";
+
+export type FooterButton =
+  | {
+      type: "link";
+      icon: LucideIcon;
+      href: string;
+      target: string;
+      title: string;
+    }
+  | {
+      type: "button";
+      icon: LucideIcon;
+      title: string;
+      onClick: () => void;
+    };
+
+interface GetFooterButtonsParams {
+  intl: Dictionary;
+  lang: string;
+  user: Session | null;
+  isLoggedIn: boolean;
+  onToggleLang: () => void;
+  onLogout: () => void;
+}
+
+export function getFooterButtons({
+  intl,
+  lang,
+  user,
+  isLoggedIn,
+  onToggleLang,
+  onLogout,
+}: GetFooterButtonsParams): FooterButton[] {
+  return [
+    {
+      type: "link",
+      icon: BookOpenIcon,
+      href: "https://bunko.alemartir.com/guides/manga",
+      target: "_blank",
+      title: intl.tooltip.userGuide as string,
+    },
+    {
+      type: "button",
+      icon: LanguagesIcon,
+      title: intl.tooltip.switchLang as string,
+      onClick: onToggleLang,
+    },
+    ...(user?.isAdmin
+      ? [
+          {
+            type: "link" as const,
+            icon: Settings2Icon,
+            href: `/${lang}/settings`,
+            target: "_self",
+            title: intl.tooltip.settings as string,
+          },
+        ]
+      : []),
+    ...(isLoggedIn
+      ? [
+          {
+            type: "button" as const,
+            icon: LogOutIcon,
+            title: intl.tooltip.logout as string,
+            onClick: onLogout,
+          },
+        ]
+      : []),
+  ];
+}