@itsmrtr/bunkoshelf 1.2.8 → 1.3.0

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

@@ -134,11 +134,39 @@ interface FindSeriesOptions {
   scope?: LibraryScope;
 }
 
+export interface SeriesVolumeAggregate {
+  communityRating: number | null;
+  format: string | null;
+  id: string;
+  writer: string | null;
+  penciller: string | null;
+  inker: string | null;
+  colorist: string | null;
+  letterer: string | null;
+  coverArtist: string | null;
+  editor: string | null;
+  publisher: string | null;
+  imprint: string | null;
+}
+
 interface FindVolumeOptions extends SharedVolumeQueryOptions {
   slug: string;
   userId?: string | null;
 }
 
+interface PagedQueryOptions {
+  page?: number;
+  pageSize?: number;
+}
+
+export interface PaginatedResult<T> {
+  items: T[];
+  total: number;
+  page: number;
+  pageSize: number;
+  totalPages: number;
+}
+
 interface VolumeRow {
   volume_id: string;
   volume_slug: string;
@@ -476,6 +504,35 @@ function buildLibraryFilterScopeConditions(
   return "";
 }
 
+function buildPagination(options?: PagedQueryOptions) {
+  const pageSize = Math.max(1, options?.pageSize ?? 1);
+  const page = Math.max(1, options?.page ?? 1);
+
+  return {
+    page,
+    pageSize,
+    offset: (page - 1) * pageSize,
+  };
+}
+
+function mapPaginatedResult<T>(
+  items: T[],
+  total: number,
+  pagination: ReturnType<typeof buildPagination>
+): PaginatedResult<T> {
+  return {
+    items,
+    total,
+    page: pagination.page,
+    pageSize: pagination.pageSize,
+    totalPages: Math.ceil(total / pagination.pageSize),
+  };
+}
+
+function parseCount(value: string | number): number {
+  return typeof value === "number" ? value : Number(value);
+}
+
 async function listLibraryFiltersRaw(scope?: LibraryScope): Promise<{
   genres: GenreFilter[];
   tags: TagFilter[];
@@ -633,7 +690,7 @@ async function listVolumesRaw(
       LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
       ${progressJoin}
       ${conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : ""}
-      ORDER BY ms.title ASC, mv.title ASC
+      ORDER BY ms.sort_title ASC, mv.sort_title ASC, mv.id ASC
     `,
     params
   );
@@ -672,6 +729,174 @@ export async function listVolumes(
   });
 }
 
+async function listPagedVolumeIdsRaw(
+  options?: VolumeQueryOptions & PagedQueryOptions
+): Promise<PaginatedResult<string>> {
+  const pagination = buildPagination(options);
+  const countParams: unknown[] = [];
+  const countConditions = buildVolumeFilterSql(
+    {
+      genreNames: options?.genreNames,
+      tagNames: options?.tagNames,
+      seriesIds: options?.seriesIds,
+      volumeIds: options?.volumeIds,
+      userId: options?.userId,
+      onlyUnreadForUser: options?.onlyUnreadForUser,
+      scope: options?.scope,
+    },
+    countParams
+  );
+  const rowsParams = [...countParams];
+
+  const [countRow, rows] = await Promise.all([
+    queryOne<{ total: string }>(
+      `
+        SELECT COUNT(*)::text AS total
+        FROM manga_volumes mv
+        LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
+        ${countConditions.length > 0 ? `WHERE ${countConditions.join(" AND ")}` : ""}
+      `,
+      countParams
+    ),
+    query<{ id: string }>(
+      `
+        SELECT mv.id
+        FROM manga_volumes mv
+        LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
+        ${countConditions.length > 0 ? `WHERE ${countConditions.join(" AND ")}` : ""}
+        ORDER BY mv.sort_title ASC, mv.id ASC
+        LIMIT $${rowsParams.push(pagination.pageSize)}
+        OFFSET $${rowsParams.push(pagination.offset)}
+      `,
+      rowsParams
+    ),
+  ]);
+
+  return mapPaginatedResult(
+    rows.map((row) => row.id),
+    parseCount(countRow?.total ?? 0),
+    pagination
+  );
+}
+
+async function listPagedVolumeIdsCached(
+  options: SharedVolumeQueryOptions & PagedQueryOptions = {}
+) {
+  "use cache";
+
+  cacheLife("max");
+  cacheTag(MANGA_LIBRARY_TAG);
+
+  return listPagedVolumeIdsRaw(options);
+}
+
+export async function listPagedVolumes(
+  options?: VolumeQueryOptions &
+    PagedQueryOptions & {
+      includeGenres?: boolean;
+      includeTags?: boolean;
+    }
+): Promise<PaginatedResult<LibraryVolume>> {
+  const pagedIds = options?.userId || options?.onlyUnreadForUser
+    ? await listPagedVolumeIdsRaw(options)
+    : await listPagedVolumeIdsCached({
+        includeGenres: options?.includeGenres,
+        includeTags: options?.includeTags,
+        genreNames: options?.genreNames,
+        tagNames: options?.tagNames,
+        seriesIds: options?.seriesIds,
+        volumeIds: options?.volumeIds,
+        scope: options?.scope,
+        page: options?.page,
+        pageSize: options?.pageSize,
+      });
+
+  if (pagedIds.items.length === 0) {
+    return {
+      ...pagedIds,
+      items: [],
+    };
+  }
+
+  const volumes = await listVolumes({
+    volumeIds: pagedIds.items,
+    includeGenres: options?.includeGenres,
+    includeTags: options?.includeTags,
+    scope: options?.scope,
+  });
+
+  const volumeMap = new Map(volumes.map((volume) => [volume.id, volume]));
+
+  return {
+    ...pagedIds,
+    items: pagedIds.items
+      .map((id) => volumeMap.get(id))
+      .filter((volume): volume is LibraryVolume => Boolean(volume)),
+  };
+}
+
+export async function listVolumeProgressByIds(
+  userId: string,
+  volumeIds: string[]
+): Promise<Record<string, UserVolumeProgress>> {
+  if (!userId || volumeIds.length === 0) {
+    return {};
+  }
+
+  const rows = await query<{
+    id: string;
+    user_id: string;
+    volume_id: string;
+    is_read: boolean;
+    is_favorite: boolean;
+    personal_rating: number | null;
+    last_page: number | null;
+    total_pages: number | null;
+    last_read_at: Date | null;
+    first_read: string | null;
+    created_at: Date;
+    updated_at: Date;
+  }>(
+    `
+      SELECT
+        id,
+        user_id,
+        volume_id,
+        is_read,
+        is_favorite,
+        personal_rating,
+        last_page,
+        total_pages,
+        last_read_at,
+        first_read,
+        created_at,
+        updated_at
+      FROM user_to_volumes
+      WHERE user_id = $1
+        AND volume_id = ANY($2::text[])
+    `,
+    [userId, volumeIds]
+  );
+
+  return rows.reduce<Record<string, UserVolumeProgress>>((acc, row) => {
+    acc[row.volume_id] = {
+      id: row.id,
+      userId: row.user_id,
+      volumeId: row.volume_id,
+      isRead: row.is_read,
+      isFavorite: row.is_favorite,
+      personalRating: row.personal_rating,
+      lastPage: row.last_page,
+      totalPages: row.total_pages,
+      lastReadAt: row.last_read_at,
+      firstRead: row.first_read,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+    };
+    return acc;
+  }, {});
+}
+
 async function listSeriesWithVolumesRaw(
   options?: SharedSeriesQueryOptions
 ): Promise<LibrarySeriesWithVolumes[]> {
@@ -728,6 +953,119 @@ export async function listSeriesWithVolumes(
   });
 }
 
+async function listPagedSeriesIdsRaw(
+  options?: SharedSeriesQueryOptions &
+    PagedQueryOptions & {
+      excludeOneshots?: boolean;
+    }
+): Promise<PaginatedResult<string>> {
+  const pagination = buildPagination(options);
+  const countParams: unknown[] = [];
+  const countConditions = buildVolumeFilterSql(
+    {
+      genreNames: options?.genreNames,
+      tagNames: options?.tagNames,
+      seriesIds: options?.seriesIds,
+      scope: options?.scope,
+    },
+    countParams
+  );
+
+  if (options?.excludeOneshots) {
+    countConditions.push("ms.is_oneshot = FALSE");
+  }
+
+  const rowsParams = [...countParams];
+  const [countRow, rows] = await Promise.all([
+    queryOne<{ total: string }>(
+      `
+        SELECT COUNT(DISTINCT ms.id)::text AS total
+        FROM manga_series ms
+        INNER JOIN manga_volumes mv ON mv.series_id = ms.id
+        LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
+        ${countConditions.length > 0 ? `WHERE ${countConditions.join(" AND ")}` : ""}
+      `,
+      countParams
+    ),
+    query<{ id: string }>(
+      `
+        SELECT ms.id
+        FROM manga_series ms
+        INNER JOIN manga_volumes mv ON mv.series_id = ms.id
+        LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
+        ${countConditions.length > 0 ? `WHERE ${countConditions.join(" AND ")}` : ""}
+        GROUP BY ms.id, ms.sort_title
+        ORDER BY ms.sort_title ASC, ms.id ASC
+        LIMIT $${rowsParams.push(pagination.pageSize)}
+        OFFSET $${rowsParams.push(pagination.offset)}
+      `,
+      rowsParams
+    ),
+  ]);
+
+  return mapPaginatedResult(
+    rows.map((row) => row.id),
+    parseCount(countRow?.total ?? 0),
+    pagination
+  );
+}
+
+async function listPagedSeriesIdsCached(
+  options: SharedSeriesQueryOptions &
+    PagedQueryOptions & {
+      excludeOneshots?: boolean;
+    } = {}
+) {
+  "use cache";
+
+  cacheLife("max");
+  cacheTag(MANGA_LIBRARY_TAG);
+
+  return listPagedSeriesIdsRaw(options);
+}
+
+export async function listPagedSeriesWithVolumes(
+  options?: SharedSeriesQueryOptions &
+    PagedQueryOptions & {
+      excludeOneshots?: boolean;
+    }
+): Promise<PaginatedResult<LibrarySeriesWithVolumes>> {
+  const pagedIds = await listPagedSeriesIdsCached({
+    genreNames: options?.genreNames,
+    tagNames: options?.tagNames,
+    seriesIds: options?.seriesIds,
+    includeGenres: options?.includeGenres,
+    includeTags: options?.includeTags,
+    scope: options?.scope,
+    page: options?.page,
+    pageSize: options?.pageSize,
+    excludeOneshots: options?.excludeOneshots,
+  });
+
+  if (pagedIds.items.length === 0) {
+    return {
+      ...pagedIds,
+      items: [],
+    };
+  }
+
+  const series = await listSeriesWithVolumes({
+    seriesIds: pagedIds.items,
+    includeGenres: options?.includeGenres,
+    includeTags: options?.includeTags,
+    scope: options?.scope,
+  });
+
+  const seriesMap = new Map(series.map((entry) => [entry.id, entry]));
+
+  return {
+    ...pagedIds,
+    items: pagedIds.items
+      .map((id) => seriesMap.get(id))
+      .filter((entry): entry is LibrarySeriesWithVolumes => Boolean(entry)),
+  };
+}
+
 export async function listSeries(
   options?: { scope?: LibraryScope }
 ): Promise<LibrarySeries[]> {
@@ -765,7 +1103,7 @@ export async function listSeries(
       INNER JOIN manga_volumes mv ON mv.series_id = ms.id
       LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
       ${conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : ""}
-      ORDER BY title ASC
+      ORDER BY ms.sort_title ASC, ms.id ASC
     `,
     params
   ).then((rows) =>
@@ -783,6 +1121,110 @@ export async function listSeries(
   );
 }
 
+export async function findSeriesBySlugBasic(
+  slug: string
+): Promise<LibrarySeries | null> {
+  const row = await queryOne<{
+    id: string;
+    slug: string;
+    title: string;
+    path: string;
+    is_oneshot: boolean;
+    mtime: Date;
+    status: string;
+    created_at: Date;
+    updated_at: Date;
+  }>(
+    `
+      SELECT
+        id,
+        slug,
+        title,
+        path,
+        is_oneshot,
+        mtime,
+        status,
+        created_at,
+        updated_at
+      FROM manga_series
+      WHERE slug = $1
+      LIMIT 1
+    `,
+    [slug]
+  );
+
+  if (!row) {
+    return null;
+  }
+
+  return {
+    id: row.id,
+    slug: row.slug,
+    title: row.title,
+    path: row.path,
+    isOneshot: row.is_oneshot,
+    mtime: row.mtime,
+    status: row.status,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
+export async function listSeriesVolumeAggregates(
+  seriesId: string
+): Promise<SeriesVolumeAggregate[]> {
+  return query<{
+    volume_id: string;
+    community_rating: number | null;
+    writer: string | null;
+    penciller: string | null;
+    inker: string | null;
+    colorist: string | null;
+    letterer: string | null;
+    cover_artist: string | null;
+    editor: string | null;
+    publisher: string | null;
+    imprint: string | null;
+    format: string | null;
+  }>(
+    `
+      SELECT
+        mv.id AS volume_id,
+        vm.community_rating,
+        vm.writer,
+        vm.penciller,
+        vm.inker,
+        vm.colorist,
+        vm.letterer,
+        vm.cover_artist,
+        vm.editor,
+        vm.publisher,
+        vm.imprint,
+        vm.format
+      FROM manga_volumes mv
+      LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
+      WHERE mv.series_id = $1
+      ORDER BY mv.sort_title ASC, mv.id ASC
+    `,
+    [seriesId]
+  ).then((rows) =>
+    rows.map((row) => ({
+      id: row.volume_id,
+      communityRating: row.community_rating,
+      writer: row.writer,
+      penciller: row.penciller,
+      inker: row.inker,
+      colorist: row.colorist,
+      letterer: row.letterer,
+      coverArtist: row.cover_artist,
+      editor: row.editor,
+      publisher: row.publisher,
+      imprint: row.imprint,
+      format: row.format,
+    }))
+  );
+}
+
 async function findSeriesBySlugRaw(
   options: FindSeriesOptions
 ): Promise<LibrarySeriesWithVolumes | null> {

package/dist/src/lib/db/migrations/003_add_natural_sort_keys.sql

@@ -0,0 +1,66 @@
+CREATE OR REPLACE FUNCTION bunko_natural_sort_key(input_text TEXT)
+RETURNS TEXT
+LANGUAGE plpgsql
+IMMUTABLE
+AS $$
+DECLARE
+  result TEXT := '';
+  current_number TEXT := '';
+  current_char TEXT;
+  i INTEGER;
+BEGIN
+  IF input_text IS NULL THEN
+    RETURN '';
+  END IF;
+
+  FOR i IN 1..char_length(input_text) LOOP
+    current_char := substr(input_text, i, 1);
+
+    IF current_char ~ '[0-9]' THEN
+      current_number := current_number || current_char;
+    ELSE
+      IF current_number <> '' THEN
+        result := result || lpad(current_number, 5, '0');
+        current_number := '';
+      END IF;
+
+      result := result || lower(current_char);
+    END IF;
+  END LOOP;
+
+  IF current_number <> '' THEN
+    result := result || lpad(current_number, 5, '0');
+  END IF;
+
+  RETURN result;
+END;
+$$;
+
+ALTER TABLE manga_series
+  ADD COLUMN IF NOT EXISTS sort_title TEXT;
+
+ALTER TABLE manga_volumes
+  ADD COLUMN IF NOT EXISTS sort_title TEXT;
+
+UPDATE manga_series
+SET sort_title = bunko_natural_sort_key(title)
+WHERE sort_title IS NULL OR sort_title = '';
+
+UPDATE manga_volumes
+SET sort_title = bunko_natural_sort_key(title)
+WHERE sort_title IS NULL OR sort_title = '';
+
+ALTER TABLE manga_series
+  ALTER COLUMN sort_title SET NOT NULL;
+
+ALTER TABLE manga_volumes
+  ALTER COLUMN sort_title SET NOT NULL;
+
+CREATE INDEX IF NOT EXISTS manga_series_sort_title_idx
+  ON manga_series (sort_title);
+
+CREATE INDEX IF NOT EXISTS manga_volumes_sort_title_idx
+  ON manga_volumes (sort_title);
+
+CREATE INDEX IF NOT EXISTS manga_volumes_series_id_sort_title_idx
+  ON manga_volumes (series_id, sort_title);

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

@@ -4,8 +4,16 @@
     "ttManga": "Manga",
     "ttSeries": "Favorite Series",
     "ttVolumes": "Favorite Volumes",
+    "ttSeriesManga": "Series - Manga",
+    "ttVolumesManga": "Volumes - Manga",
+    "ttSeriesOthers": "Series - Comic/Others",
+    "ttVolumesOthers": "Volumes - Comic/Others",
     "sectionManga": "Manga",
+    "sectionMangaSeries": "Manga - Series",
+    "sectionMangaVolumes": "Manga - Volumes",
     "sectionOthers": "Comic/Others",
+    "sectionOthersSeries": "Comic/Others - Series",
+    "sectionOthersVolumes": "Comic/Others - Volumes",
     "sectionBooks": "Books"
   }
 }

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

@@ -53,10 +53,6 @@
     "uploadLibraryBtn": "Upload Files",
     "storageLocal": "Local Library",
     "storageCloud": "Remote Library",
-    "othersLibraryTitle": "Comic/Others Mode",
-    "othersLibraryDesc": "Separates titles with manga = No into a secondary library and enables the /others route.",
-    "othersLibraryEnabled": "Enabled",
-    "othersLibraryDisabled": "Disabled",
     "reindexing": "Reindexing...",
     "reindex": "Reindex Library",
     "regeneratingCovers": "Regenerating...",

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

@@ -3,9 +3,17 @@
     "title": "Favoritos",
     "ttManga": "Manga",
     "ttSeries": "Series favoritas",
-    "ttVolumes": "Volúmenes favoritos",
+    "ttVolumes": "Tomos favoritos",
+    "ttSeriesManga": "Series - Manga",
+    "ttVolumesManga": "Tomos - Manga",
+    "ttSeriesOthers": "Series - Cómic/Otros",
+    "ttVolumesOthers": "Tomos - Cómic/Otros",
     "sectionManga": "Mangas",
-    "sectionOthers": "Comic/Otros",
+    "sectionMangaSeries": "Mangas - Series",
+    "sectionMangaVolumes": "Mangas - Tomos",
+    "sectionOthers": "Cómic/Otros",
+    "sectionOthersSeries": "Cómic/Otros - Series",
+    "sectionOthersVolumes": "Cómic/Otros - Tomos",
     "sectionBooks": "Libros"
   }
 }

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

@@ -2,7 +2,7 @@
   "settings": {
     "title": "Ajustes",
     "overview": "General",
-    "totalVolumes": "Volúmenes totales",
+    "totalVolumes": "Tomos totales",
     "totalSeries": "Series totales",
     "totalAddedMonth": "Añadidos este mes",
     "totalUsers": "Usuarios totales",
@@ -53,10 +53,6 @@
     "uploadLibraryBtn": "Subir Archivos",
     "storageLocal": "Biblioteca local",
     "storageCloud": "Biblioteca remota",
-    "othersLibraryTitle": "Modo Comic/Otros",
-    "othersLibraryDesc": "Separa los títulos con manga = No en una biblioteca secundaria y habilita la ruta /others.",
-    "othersLibraryEnabled": "Activado",
-    "othersLibraryDisabled": "Desactivado",
     "reindexing": "Reindexando...",
     "reindex": "Reindexar biblioteca",
     "regeneratingCovers": "Regenerando...",
@@ -64,4 +60,4 @@
     "reprocessingMeta": "Procesando...",
     "reprocessMetadata": "Procesar metadatos"
   }
-}
+}

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

@@ -2,8 +2,8 @@
   "sidebar": {
     "home": "Inicio",
     "library": "Biblioteca",
-    "manga": "Manga",
-    "others": "Comic/Otros",
+    "manga": "Mangas",
+    "others": "Cómic/Otros",
     "books": "Libros",
     "favorites": "Favoritos",
     "profile": "Perfil"

package/dist/src/lib/libraryPagination.ts

@@ -0,0 +1 @@
+export const LIBRARY_PAGE_SIZE = 35;

package/dist/src/lib/librarySection.ts

@@ -5,22 +5,18 @@ export function isOthersLibraryItem(mangaStyle: string | null | undefined) {
   return mangaStyle === "No";
 }
 
-export function getLibraryScope(
-  section: LibrarySection,
-  isOthersEnabled: boolean
-): LibraryScope {
+export function getLibraryScope(section: LibrarySection): LibraryScope {
   if (section === "others") {
     return "others";
   }
 
-  return isOthersEnabled ? "manga" : "all";
+  return "manga";
 }
 
 export function getLibrarySection(
-  mangaStyle: string | null | undefined,
-  isOthersEnabled: boolean
+  mangaStyle: string | null | undefined
 ): LibrarySection {
-  if (isOthersEnabled && isOthersLibraryItem(mangaStyle)) {
+  if (isOthersLibraryItem(mangaStyle)) {
     return "others";
   }
 
@@ -50,5 +46,5 @@ export function getLibraryVolumeHref(
 export function getFavoritesHref(lang: string, section: LibrarySection) {
   return section === "others"
     ? `/${lang}/favorites/others`
-    : `/${lang}/favorites`;
+    : `/${lang}/favorites/manga`;
 }

package/dist/src/lib/naturalSort.ts

@@ -0,0 +1,7 @@
+export function buildNaturalSortKey(value: string | null | undefined): string {
+  if (!value) {
+    return "";
+  }
+
+  return value.replace(/\d+/g, (num) => num.padStart(5, "0")).toLowerCase();
+}