@itsmrtr/bunkoshelf 1.12.0 → 1.13.0

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

@@ -0,0 +1,242 @@
+import { createId } from "@paralleldrive/cuid2";
+import { execute, query, queryOne } from "./query";
+
+export type ClubMemberStatus = "PENDING" | "APPROVED" | "REJECTED" | "REVOKED";
+export type ClubCycleStatus = "DRAFT" | "VOTING" | "READING" | "COMPLETED";
+export type ClubSourceType = "LIBRARY_SERIES" | "BOOK_SERIES";
+
+export interface ReadingClub {
+  id: string;
+  slug: string;
+  name: string;
+  description: string | null;
+  ownerId: string;
+  status: "ACTIVE" | "ARCHIVED";
+  createdAt: Date;
+}
+
+export interface ClubMember {
+  id: string;
+  userId: string;
+  username: string;
+  name: string | null;
+  role: string;
+  status: ClubMemberStatus;
+  progress: number | null;
+}
+
+export interface ClubCycle {
+  id: string;
+  title: string;
+  status: ClubCycleStatus;
+  voteClosesAt: Date | null;
+  selectedType: ClubSourceType | null;
+  selectedId: string | null;
+  workTitle: string | null;
+  startedAt: Date | null;
+}
+
+function mapClub(row: Record<string, unknown>): ReadingClub {
+  return { id: row.id as string, slug: row.slug as string, name: row.name as string, description: row.description as string | null, ownerId: row.owner_id as string, status: row.status as ReadingClub["status"], createdAt: row.created_at as Date };
+}
+
+export async function findClubBySlug(slug: string): Promise<ReadingClub | null> {
+  const row = await queryOne<Record<string, unknown>>("SELECT * FROM reading_clubs WHERE slug = $1", [slug]);
+  return row ? mapClub(row) : null;
+}
+
+export async function listClubsForUser(userId: string): Promise<ReadingClub[]> {
+  const rows = await query<Record<string, unknown>>(`
+    SELECT DISTINCT c.* FROM reading_clubs c
+    LEFT JOIN reading_club_members m ON m.club_id = c.id
+    WHERE c.owner_id = $1 OR (m.user_id = $1 AND m.status = 'APPROVED')
+    ORDER BY c.status, c.created_at DESC`, [userId]);
+  return rows.map(mapClub);
+}
+
+export async function getMembership(clubId: string, userId: string): Promise<{ id: string; status: ClubMemberStatus } | null> {
+  return queryOne<{ id: string; status: ClubMemberStatus }>(
+    "SELECT id, status FROM reading_club_members WHERE club_id = $1 AND user_id = $2", [clubId, userId]);
+}
+
+export async function canManageClub(club: ReadingClub, userId: string, isAdmin: boolean): Promise<boolean> {
+  return isAdmin || club.ownerId === userId;
+}
+
+export async function canAccessClub(club: ReadingClub, userId: string, isAdmin: boolean): Promise<boolean> {
+  if (isAdmin || club.ownerId === userId) return true;
+  const member = await getMembership(club.id, userId);
+  return club.status === "ACTIVE" && member?.status === "APPROVED";
+}
+
+export async function createClubRecord(input: { slug: string; name: string; description?: string; ownerId: string }): Promise<ReadingClub> {
+  const row = await queryOne<Record<string, unknown>>(`
+    INSERT INTO reading_clubs (id, slug, name, description, owner_id)
+    VALUES ($1, $2, $3, $4, $5) RETURNING *`,
+  [createId(), input.slug, input.name, input.description ?? null, input.ownerId]);
+  if (!row) throw new Error("Could not create club");
+  return mapClub(row);
+}
+
+export async function createInviteRecord(clubId: string, tokenHash: string, createdBy: string): Promise<void> {
+  await execute("INSERT INTO reading_club_invites (id, club_id, token_hash, created_by) VALUES ($1,$2,$3,$4)", [createId(), clubId, tokenHash, createdBy]);
+}
+
+export async function findInviteByTokenHash(tokenHash: string) {
+  return queryOne<{ id: string; club_id: string; club_slug: string; club_name: string; club_status: "ACTIVE" | "ARCHIVED" }>(`
+    SELECT i.id, i.club_id, c.slug AS club_slug, c.name AS club_name, c.status AS club_status
+    FROM reading_club_invites i INNER JOIN reading_clubs c ON c.id = i.club_id
+    WHERE i.token_hash = $1 AND i.revoked_at IS NULL`, [tokenHash]);
+}
+
+export async function requestMembership(clubId: string, userId: string): Promise<void> {
+  await execute(`INSERT INTO reading_club_members (id, club_id, user_id, status)
+    VALUES ($1,$2,$3,'PENDING') ON CONFLICT (club_id, user_id)
+    DO UPDATE SET status = CASE WHEN reading_club_members.status IN ('REJECTED','REVOKED') THEN 'PENDING' ELSE reading_club_members.status END`,
+  [createId(), clubId, userId]);
+}
+
+export async function reviewMembership(memberId: string, status: Extract<ClubMemberStatus, "APPROVED" | "REJECTED" | "REVOKED">): Promise<void> {
+  await execute("UPDATE reading_club_members SET status = $2, reviewed_at = NOW() WHERE id = $1", [memberId, status]);
+}
+
+export async function createCycleRecord(clubId: string, title: string, voteClosesAt: Date | null): Promise<ClubCycle> {
+  const row = await queryOne<Record<string, unknown>>(`INSERT INTO reading_club_cycles (id, club_id, title, status, vote_closes_at)
+    VALUES ($1,$2,$3,$4,$5) RETURNING id,title,status,vote_closes_at,selected_type,selected_id,started_at`,
+  [createId(), clubId, title, "DRAFT", voteClosesAt]);
+  if (!row) throw new Error("Could not create cycle");
+  return mapCycle(row);
+}
+
+function mapCycle(row: Record<string, unknown>): ClubCycle {
+  return { id: row.id as string, title: row.title as string, status: row.status as ClubCycleStatus, voteClosesAt: row.vote_closes_at as Date | null, selectedType: row.selected_type as ClubSourceType | null, selectedId: row.selected_id as string | null, workTitle: row.work_title as string | null, startedAt: row.started_at as Date | null };
+}
+
+export async function addCandidateRecord(cycleId: string, sourceType: ClubSourceType, sourceId: string): Promise<void> {
+  await execute("INSERT INTO reading_club_candidates (id, cycle_id, source_type, source_id) VALUES ($1,$2,$3,$4) ON CONFLICT DO NOTHING", [createId(), cycleId, sourceType, sourceId]);
+}
+
+export async function replaceCycleCandidates(cycleId: string, candidates: Array<{ sourceType: ClubSourceType; sourceId: string }>): Promise<void> {
+  await execute("DELETE FROM reading_club_candidates WHERE cycle_id=$1", [cycleId]);
+  for (const candidate of candidates) await addCandidateRecord(cycleId, candidate.sourceType, candidate.sourceId);
+}
+
+export async function removeCandidateRecord(candidateId: string, cycleId: string): Promise<void> {
+  await execute("DELETE FROM reading_club_candidates WHERE id=$1 AND cycle_id=$2", [candidateId, cycleId]);
+}
+
+export async function selectCycleWork(cycleId: string, sourceType: ClubSourceType, sourceId: string): Promise<void> {
+  await execute(`UPDATE reading_club_cycles SET selected_type=$2, selected_id=$3, status='READING', started_at=COALESCE(started_at,NOW()), updated_at=NOW() WHERE id=$1`, [cycleId, sourceType, sourceId]);
+}
+
+export async function addMilestoneRecord(cycleId: string, position: number, label: string, targetDate: string): Promise<void> {
+  await execute("INSERT INTO reading_club_milestones (id,cycle_id,position,label,target_date) VALUES ($1,$2,$3,$4,$5)", [createId(), cycleId, position, label, targetDate]);
+}
+
+export async function castVoteRecord(cycleId: string, candidateId: string, memberId: string): Promise<void> {
+  await execute(`INSERT INTO reading_club_votes (id,cycle_id,candidate_id,member_id) VALUES ($1,$2,$3,$4)
+    ON CONFLICT (cycle_id, member_id) DO UPDATE SET candidate_id=EXCLUDED.candidate_id, created_at=NOW()`, [createId(), cycleId, candidateId, memberId]);
+}
+
+export async function archiveClubRecord(clubId: string): Promise<void> {
+  await execute("UPDATE reading_clubs SET status='ARCHIVED', archived_at=NOW(), updated_at=NOW() WHERE id=$1", [clubId]);
+  await execute("UPDATE reading_club_invites SET revoked_at=NOW() WHERE club_id=$1 AND revoked_at IS NULL", [clubId]);
+  await execute(`UPDATE users SET disabled_at=NOW() FROM reading_club_guest_accounts g
+    WHERE g.club_id=$1 AND g.user_id=users.id`, [clubId]);
+}
+
+export async function deleteClubRecord(clubId: string): Promise<void> {
+  await execute(`DELETE FROM users WHERE id IN (
+    SELECT user_id FROM reading_club_guest_accounts WHERE club_id=$1
+  )`, [clubId]);
+  await execute("DELETE FROM reading_clubs WHERE id=$1", [clubId]);
+}
+
+export async function getClubDashboard(club: ReadingClub, userId: string) {
+  const [members, cycles, activities] = await Promise.all([
+    query<Record<string, unknown>>(`SELECT m.id,m.user_id,u.username,u.name,u.role,m.status
+      FROM reading_club_members m INNER JOIN users u ON u.id=m.user_id WHERE m.club_id=$1 AND m.status <> 'REVOKED' ORDER BY m.status, COALESCE(u.name,u.username)`, [club.id]),
+    query<Record<string, unknown>>(`SELECT c.id,c.title,c.status,c.vote_closes_at,c.selected_type,c.selected_id,c.started_at,
+      COALESCE(ls.title,bs.title) AS work_title FROM reading_club_cycles c
+      LEFT JOIN library_series ls ON c.selected_type='LIBRARY_SERIES' AND ls.id=c.selected_id
+      LEFT JOIN book_series bs ON c.selected_type='BOOK_SERIES' AND bs.id=c.selected_id
+      WHERE c.club_id=$1 ORDER BY c.created_at DESC`, [club.id]),
+    query<{ id: string; type: string; created_at: Date; username: string; name: string | null; label: string | null }>(`
+      SELECT a.id,a.type,a.created_at,u.username,u.name,ms.label FROM reading_club_activities a
+      INNER JOIN reading_club_members m ON m.id=a.member_id INNER JOIN users u ON u.id=m.user_id
+      LEFT JOIN reading_club_milestones ms ON ms.id=a.milestone_id WHERE a.club_id=$1 ORDER BY a.created_at DESC LIMIT 50`, [club.id]),
+  ]);
+  const active = cycles.map(mapCycle).find((cycle) => cycle.status === "READING") ?? null;
+  const memberProgress = await listMemberProgress(active, members.map((member) => ({ id: member.id as string, userId: member.user_id as string })));
+  return {
+    club,
+    currentUserMembership: await getMembership(club.id, userId),
+    members: members.map((member) => ({ id: member.id as string, userId: member.user_id as string, username: member.username as string, name: member.name as string | null, role: member.role as string, status: member.status as ClubMemberStatus, progress: memberProgress.get(member.user_id as string) ?? null } satisfies ClubMember)),
+    cycles: cycles.map(mapCycle),
+    activities,
+  };
+}
+
+async function listMemberProgress(cycle: ClubCycle | null, members: { id: string; userId: string }[]): Promise<Map<string, number>> {
+  if (!cycle?.selectedId || !cycle.selectedType || !members.length) return new Map();
+  const userIds = members.map((member) => member.userId);
+  const rows = cycle.selectedType === "LIBRARY_SERIES"
+    ? await query<{ user_id: string; progress: number }>(`SELECT ids.user_id, AVG(CASE WHEN u.is_read THEN 1 WHEN u.total_pages > 0 THEN LEAST(1, GREATEST(0, (u.last_page + 1)::float / u.total_pages)) ELSE 0 END) AS progress
+      FROM unnest($2::text[]) AS ids(user_id) CROSS JOIN library_volumes v
+      LEFT JOIN user_to_volumes u ON u.volume_id=v.id AND u.user_id=ids.user_id
+      WHERE v.series_id=$1 GROUP BY ids.user_id`, [cycle.selectedId, userIds])
+    : await query<{ user_id: string; progress: number }>(`SELECT ids.user_id, AVG(CASE WHEN u.is_read THEN 1 ELSE COALESCE(u.progression,0) END) AS progress
+      FROM unnest($2::text[]) AS ids(user_id) CROSS JOIN book_volumes v
+      LEFT JOIN user_to_books u ON u.volume_id=v.id AND u.user_id=ids.user_id
+      WHERE v.series_id=$1 GROUP BY ids.user_id`, [cycle.selectedId, userIds]);
+  return new Map(rows.map((row) => [row.user_id, Number(row.progress)]));
+}
+
+export async function listClubWorks() {
+  const [library, books] = await Promise.all([
+    query<{ id: string; title: string; section: string; is_oneshot: boolean }>("SELECT id,title,library_section AS section,is_oneshot FROM library_series WHERE library_section IN ('manga','comic') ORDER BY title"),
+    query<{ id: string; title: string; section: string; is_oneshot: boolean }>("SELECT id,title,'books' AS section,is_oneshot FROM book_series WHERE library_section='books' ORDER BY title"),
+  ]);
+  return [...library.map((work) => ({ ...work, type: "LIBRARY_SERIES" as const })), ...books.map((work) => ({ ...work, type: "BOOK_SERIES" as const }))];
+}
+
+export async function listCycleCandidates(cycleId: string) {
+  return query<{ id: string; source_type: ClubSourceType; source_id: string; title: string | null; section: string | null; is_oneshot: boolean; votes: string }>(`
+    SELECT ca.id,ca.source_type,ca.source_id,COALESCE(ls.title,bs.title) AS title,COALESCE(ls.library_section,bs.library_section) AS section,COALESCE(ls.is_oneshot,bs.is_oneshot,FALSE) AS is_oneshot,COUNT(v.id)::text AS votes
+    FROM reading_club_candidates ca LEFT JOIN library_series ls ON ca.source_type='LIBRARY_SERIES' AND ls.id=ca.source_id
+    LEFT JOIN book_series bs ON ca.source_type='BOOK_SERIES' AND bs.id=ca.source_id
+    LEFT JOIN reading_club_votes v ON v.candidate_id=ca.id WHERE ca.cycle_id=$1
+    GROUP BY ca.id,ls.title,bs.title,ls.library_section,bs.library_section,ls.is_oneshot,bs.is_oneshot ORDER BY title`, [cycleId]);
+}
+
+export async function listCycleMilestones(cycleId: string) {
+  return query<{ id: string; position: number; label: string; target_date: string }>(
+    "SELECT id,position,label,target_date::text FROM reading_club_milestones WHERE cycle_id=$1 ORDER BY position", [cycleId]);
+}
+
+export async function listSelectedCycleVolumes(cycle: ClubCycle | null) {
+  if (!cycle?.selectedId || !cycle.selectedType) return [];
+  if (cycle.selectedType === "LIBRARY_SERIES") return query<{ slug: string; title: string; kind: "manga"; manga_style: string | null }>(`
+    SELECT v.slug,v.title,'manga'::text AS kind,md.manga_style FROM library_volumes v
+    LEFT JOIN volume_metadata md ON md.id=v.metadata_id WHERE v.series_id=$1 ORDER BY v.created_at`, [cycle.selectedId]);
+  return query<{ slug: string; title: string; kind: "books"; manga_style: null }>(`
+    SELECT slug,title,'books'::text AS kind,NULL::text AS manga_style FROM book_volumes WHERE series_id=$1 ORDER BY number NULLS FIRST,title`, [cycle.selectedId]);
+}
+
+export async function recordClubProgressActivities(userId: string, sourceType: ClubSourceType, sourceId: string): Promise<void> {
+  const progressRow = sourceType === "LIBRARY_SERIES"
+    ? await queryOne<{ progress: number }>(`SELECT AVG(CASE WHEN u.is_read THEN 1 WHEN u.total_pages > 0 THEN LEAST(1, GREATEST(0, (u.last_page + 1)::float / u.total_pages)) ELSE 0 END) AS progress
+      FROM library_volumes v LEFT JOIN user_to_volumes u ON u.volume_id=v.id AND u.user_id=$1 WHERE v.series_id=$2`, [userId, sourceId])
+    : await queryOne<{ progress: number }>(`SELECT AVG(CASE WHEN u.is_read THEN 1 ELSE COALESCE(u.progression,0) END) AS progress
+      FROM book_volumes v LEFT JOIN user_to_books u ON u.volume_id=v.id AND u.user_id=$1 WHERE v.series_id=$2`, [userId, sourceId]);
+  const progress = Number(progressRow?.progress ?? 0);
+  const rows = await query<{ club_id: string; cycle_id: string; member_id: string; milestone_id: string | null; position: number }>(`
+    SELECT c.club_id,c.id AS cycle_id,m.id AS member_id,ms.id AS milestone_id,ms.position
+    FROM reading_club_cycles c INNER JOIN reading_club_members m ON m.club_id=c.club_id AND m.user_id=$1 AND m.status='APPROVED'
+    LEFT JOIN reading_club_milestones ms ON ms.cycle_id=c.id
+    WHERE c.status='READING' AND c.selected_type=$2 AND c.selected_id=$3`, [userId, sourceType, sourceId]);
+  for (const row of rows) {
+    if (progress >= 1) await execute(`INSERT INTO reading_club_activities (id,club_id,cycle_id,member_id,type) VALUES ($1,$2,$3,$4,'COMPLETED') ON CONFLICT DO NOTHING`, [createId(), row.club_id, row.cycle_id, row.member_id]);
+    if (row.milestone_id && progress * 100 >= row.position) await execute(`INSERT INTO reading_club_activities (id,club_id,cycle_id,member_id,milestone_id,type) VALUES ($1,$2,$3,$4,$5,'MILESTONE_REACHED') ON CONFLICT DO NOTHING`, [createId(), row.club_id, row.cycle_id, row.member_id, row.milestone_id]);
+  }
+}

package/dist/src/lib/db/migrations/012_reading_clubs.sql

@@ -0,0 +1,100 @@
+ALTER TABLE users ADD COLUMN IF NOT EXISTS disabled_at TIMESTAMP;
+
+CREATE TABLE IF NOT EXISTS reading_clubs (
+  id TEXT PRIMARY KEY,
+  slug TEXT NOT NULL UNIQUE,
+  name TEXT NOT NULL,
+  description TEXT,
+  owner_id TEXT NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
+  status TEXT NOT NULL DEFAULT 'ACTIVE' CHECK (status IN ('ACTIVE', 'ARCHIVED')),
+  archived_at TIMESTAMP,
+  created_at TIMESTAMP NOT NULL DEFAULT NOW(),
+  updated_at TIMESTAMP NOT NULL DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS reading_club_members (
+  id TEXT PRIMARY KEY,
+  club_id TEXT NOT NULL REFERENCES reading_clubs(id) ON DELETE CASCADE,
+  user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  status TEXT NOT NULL DEFAULT 'PENDING' CHECK (status IN ('PENDING', 'APPROVED', 'REJECTED', 'REVOKED')),
+  created_at TIMESTAMP NOT NULL DEFAULT NOW(),
+  reviewed_at TIMESTAMP,
+  UNIQUE (club_id, user_id)
+);
+
+CREATE TABLE IF NOT EXISTS reading_club_invites (
+  id TEXT PRIMARY KEY,
+  club_id TEXT NOT NULL REFERENCES reading_clubs(id) ON DELETE CASCADE,
+  token_hash TEXT NOT NULL UNIQUE,
+  created_by TEXT NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
+  revoked_at TIMESTAMP,
+  created_at TIMESTAMP NOT NULL DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS reading_club_guest_accounts (
+  user_id TEXT PRIMARY KEY REFERENCES users(id) ON DELETE CASCADE,
+  club_id TEXT NOT NULL REFERENCES reading_clubs(id) ON DELETE CASCADE,
+  created_at TIMESTAMP NOT NULL DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS reading_club_cycles (
+  id TEXT PRIMARY KEY,
+  club_id TEXT NOT NULL REFERENCES reading_clubs(id) ON DELETE CASCADE,
+  title TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'DRAFT' CHECK (status IN ('DRAFT', 'VOTING', 'READING', 'COMPLETED')),
+  vote_closes_at TIMESTAMP,
+  selected_type TEXT CHECK (selected_type IN ('LIBRARY_SERIES', 'BOOK_SERIES')),
+  selected_id TEXT,
+  started_at TIMESTAMP,
+  completed_at TIMESTAMP,
+  created_at TIMESTAMP NOT NULL DEFAULT NOW(),
+  updated_at TIMESTAMP NOT NULL DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS reading_club_candidates (
+  id TEXT PRIMARY KEY,
+  cycle_id TEXT NOT NULL REFERENCES reading_club_cycles(id) ON DELETE CASCADE,
+  source_type TEXT NOT NULL CHECK (source_type IN ('LIBRARY_SERIES', 'BOOK_SERIES')),
+  source_id TEXT NOT NULL,
+  created_at TIMESTAMP NOT NULL DEFAULT NOW(),
+  UNIQUE (cycle_id, source_type, source_id)
+);
+
+CREATE TABLE IF NOT EXISTS reading_club_votes (
+  id TEXT PRIMARY KEY,
+  cycle_id TEXT NOT NULL REFERENCES reading_club_cycles(id) ON DELETE CASCADE,
+  candidate_id TEXT NOT NULL REFERENCES reading_club_candidates(id) ON DELETE CASCADE,
+  member_id TEXT NOT NULL REFERENCES reading_club_members(id) ON DELETE CASCADE,
+  created_at TIMESTAMP NOT NULL DEFAULT NOW(),
+  UNIQUE (cycle_id, member_id)
+);
+
+CREATE TABLE IF NOT EXISTS reading_club_milestones (
+  id TEXT PRIMARY KEY,
+  cycle_id TEXT NOT NULL REFERENCES reading_club_cycles(id) ON DELETE CASCADE,
+  position INTEGER NOT NULL CHECK (position BETWEEN 1 AND 100),
+  label TEXT NOT NULL,
+  target_date DATE NOT NULL,
+  created_at TIMESTAMP NOT NULL DEFAULT NOW(),
+  UNIQUE (cycle_id, position)
+);
+
+CREATE TABLE IF NOT EXISTS reading_club_activities (
+  id TEXT PRIMARY KEY,
+  club_id TEXT NOT NULL REFERENCES reading_clubs(id) ON DELETE CASCADE,
+  cycle_id TEXT NOT NULL REFERENCES reading_club_cycles(id) ON DELETE CASCADE,
+  member_id TEXT NOT NULL REFERENCES reading_club_members(id) ON DELETE CASCADE,
+  milestone_id TEXT REFERENCES reading_club_milestones(id) ON DELETE CASCADE,
+  type TEXT NOT NULL CHECK (type IN ('MILESTONE_REACHED', 'COMPLETED')),
+  created_at TIMESTAMP NOT NULL DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS reading_club_members_user_idx ON reading_club_members(user_id, status);
+CREATE INDEX IF NOT EXISTS reading_club_cycles_club_idx ON reading_club_cycles(club_id, status);
+CREATE INDEX IF NOT EXISTS reading_club_activities_cycle_idx ON reading_club_activities(cycle_id, created_at DESC);
+CREATE UNIQUE INDEX IF NOT EXISTS reading_club_activities_milestone_unique
+  ON reading_club_activities(cycle_id, member_id, milestone_id)
+  WHERE type = 'MILESTONE_REACHED';
+CREATE UNIQUE INDEX IF NOT EXISTS reading_club_activities_completed_unique
+  ON reading_club_activities(cycle_id, member_id)
+  WHERE type = 'COMPLETED';

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

@@ -34,7 +34,7 @@ export async function findUserByUsername(
       SELECT id, created_at, username, password, is_admin, role, name, lastname, birth_year
       , profile_image
       FROM users
-      WHERE username = $1
+      WHERE username = $1 AND disabled_at IS NULL
       LIMIT 1
     `,
     [username]
@@ -49,7 +49,7 @@ export async function findUserSessionById(id: string): Promise<PublicUser | null
       SELECT id, created_at, username, password, is_admin, role, name, lastname, birth_year
       , profile_image
       FROM users
-      WHERE id = $1
+      WHERE id = $1 AND disabled_at IS NULL
       LIMIT 1
     `,
     [id]

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

@@ -26,6 +26,7 @@ const dictionaries: Record<Locale, () => Promise<Record<string, DictionarySectio
       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),
+      import("./dictionaries/en/clubs.json").then((m) => m.default),
     ]),
   es: () =>
     Promise.all([
@@ -51,6 +52,7 @@ const dictionaries: Record<Locale, () => Promise<Record<string, DictionarySectio
       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),
+      import("./dictionaries/es/clubs.json").then((m) => m.default),
     ]),
 };
 

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

@@ -0,0 +1,72 @@
+{
+  "clubs": {
+    "title": "Reading clubs",
+    "intro": "Your shared readings, votes, and reading pace.",
+    "createTitle": "Create a club",
+    "clubName": "Club name",
+    "description": "Optional description",
+    "create": "Create club",
+    "active": "Active",
+    "archived": "Archived",
+    "empty": "You do not belong to a club yet.",
+    "clubLabel": "Reading club",
+    "readingNow": "Currently reading",
+    "readingPace": "Milestones set the pace, but the full work is available.",
+    "read": "Read",
+    "finishCycle": "Finish this cycle",
+    "voting": "Vote",
+    "closes": "Closes",
+    "noDate": "no date",
+    "votes": "votes",
+    "choose": "Choose",
+    "participants": "Participants",
+    "activity": "Activity",
+    "approved": "Approved",
+    "pending": "Pending",
+    "rejected": "Rejected",
+    "revoked": "Revoked",
+    "accept": "Accept",
+    "reject": "Reject",
+    "completedReading": "finished the reading",
+    "reachedMilestone": "reached the milestone",
+    "noActivity": "No activity has been recorded yet.",
+    "manage": "Manage",
+    "createInvite": "Create invitation",
+    "nextCycle": "Next cycle name",
+    "voteDeadline": "Voting deadline",
+    "voteDeadlineOptional": "Voting deadline (optional)",
+    "createCycle": "Create cycle",
+    "openVote": "Open vote",
+    "addCandidate": "Add candidate",
+    "chooseWork": "Choose work and start reading",
+    "removeCandidate": "Remove candidate",
+    "removeCandidateTitle": "Remove candidate",
+    "removeCandidateDescription": "This candidate will be removed from the vote.",
+    "removeMember": "Remove participant",
+    "remove": "Remove",
+    "removeMemberTitle": "Remove participant",
+    "removeMemberDescription": "This person will lose access to the club.",
+    "archiveTitle": "Archive club",
+    "archiveDescription": "The club will be kept as history, but invitations and guest access will be revoked.",
+    "deleteClub": "Delete club",
+    "deleteClubTitle": "Permanently delete club",
+    "deleteClubDescription": "The club, its cycles, candidates, votes, milestones, activities, and invitations will be deleted. This cannot be undone.",
+    "confirmReading": "Confirm reading",
+    "startVote": "Start vote",
+    "chooseDifferentWorks": "Choose a different work for each candidate.",
+    "voteDeadlineRequired": "Choose a future date before starting the vote.",
+    "archive": "Archive club",
+    "milestones": "Milestones",
+    "milestoneLabel": "For example, Volume 3",
+    "milestonePosition": "Percentage",
+    "addMilestone": "Add milestone",
+    "selectWorkForMilestones": "Choose a work before adding milestones.",
+    "inviteLabel": "Private invitation",
+    "invitePending": "Your request will be pending until the club owner approves it.",
+    "requestJoin": "Request to join",
+    "joinGuest": "Join as a guest",
+    "username": "Username",
+    "password": "Password (8 characters minimum)",
+    "createGuest": "Create access and request"
+  }
+}

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

@@ -4,7 +4,7 @@
     "contents": "Contents",
     "addBookmark": "Add bookmark",
     "removeBookmark": "Remove bookmark",
-    "settings": "Reading settings",
+    "settings": "Settings",
     "close": "Close reader",
     "theme": "Theme",
     "light": "Light",

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

@@ -8,6 +8,7 @@
     "books": "Books",
     "favorites": "Favorites",
     "catalog": "Catalog",
+    "clubs": "Clubs",
     "profile": "Profile"
   }
 }

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

@@ -0,0 +1,72 @@
+{
+  "clubs": {
+    "title": "Clubes de lectura",
+    "intro": "Tus lecturas compartidas, votaciones y ritmo de lectura.",
+    "createTitle": "Crear un club",
+    "clubName": "Nombre del club",
+    "description": "Descripción opcional",
+    "create": "Crear club",
+    "active": "Activo",
+    "archived": "Archivado",
+    "empty": "Todavía no pertenecés a ningún club.",
+    "clubLabel": "Club de lectura",
+    "readingNow": "Leyendo ahora",
+    "readingPace": "Los hitos marcan el ritmo, pero la obra completa está disponible.",
+    "read": "Leer",
+    "finishCycle": "Finalizar este ciclo",
+    "voting": "Votación",
+    "closes": "Cierra",
+    "noDate": "sin fecha",
+    "votes": "votos",
+    "choose": "Elegir",
+    "participants": "Participantes",
+    "activity": "Actividad",
+    "approved": "Aprobado",
+    "pending": "Pendiente",
+    "rejected": "Rechazado",
+    "revoked": "Revocado",
+    "accept": "Aceptar",
+    "reject": "Rechazar",
+    "completedReading": "terminó la lectura",
+    "reachedMilestone": "alcanzó el hito",
+    "noActivity": "Aún no hay actividad registrada.",
+    "manage": "Administrar",
+    "createInvite": "Crear invitación",
+    "nextCycle": "Nombre del siguiente ciclo",
+    "voteDeadline": "Fecha límite para votar",
+    "voteDeadlineOptional": "Fecha límite para votar (opcional)",
+    "createCycle": "Crear ciclo",
+    "openVote": "Abrir votación",
+    "addCandidate": "Añadir candidata",
+    "chooseWork": "Elegir obra y comenzar lectura",
+    "removeCandidate": "Quitar candidata",
+    "removeCandidateTitle": "Quitar candidata",
+    "removeCandidateDescription": "La candidata se eliminará de esta votación.",
+    "removeMember": "Remover participante",
+    "remove": "Remover",
+    "removeMemberTitle": "Remover participante",
+    "removeMemberDescription": "Esta persona perderá acceso al club.",
+    "archiveTitle": "Archivar club",
+    "archiveDescription": "El club se conservará como historial, pero se revocarán las invitaciones y el acceso de invitados.",
+    "deleteClub": "Eliminar club",
+    "deleteClubTitle": "Eliminar club permanentemente",
+    "deleteClubDescription": "Se eliminarán el club, sus ciclos, candidatas, votos, hitos, actividades e invitaciones. Esta acción no se puede deshacer.",
+    "confirmReading": "Confirmar lectura",
+    "startVote": "Iniciar votación",
+    "chooseDifferentWorks": "Elegí obras distintas para cada candidata.",
+    "voteDeadlineRequired": "Definí una fecha futura para iniciar la votación.",
+    "archive": "Archivar club",
+    "milestones": "Hitos",
+    "milestoneLabel": "Ej. Volumen 3",
+    "milestonePosition": "Porcentaje",
+    "addMilestone": "Añadir hito",
+    "selectWorkForMilestones": "Seleccioná una obra para poder añadir hitos.",
+    "inviteLabel": "Invitación privada",
+    "invitePending": "Tu solicitud quedará pendiente hasta que el owner del club la apruebe.",
+    "requestJoin": "Solicitar unirme",
+    "joinGuest": "Unirme como invitado",
+    "username": "Nombre de usuario",
+    "password": "Contraseña (8 caracteres mínimo)",
+    "createGuest": "Crear acceso y solicitar"
+  }
+}

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

@@ -4,7 +4,7 @@
     "contents": "Contenido",
     "addBookmark": "Agregar marcador",
     "removeBookmark": "Eliminar marcador",
-    "settings": "Ajustes de lectura",
+    "settings": "Ajustes",
     "close": "Cerrar lector",
     "theme": "Tema",
     "light": "Claro",

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

@@ -8,6 +8,7 @@
     "books": "Libros",
     "favorites": "Favoritos",
     "catalog": "Catálogo",
+    "clubs": "Clubes",
     "profile": "Perfil"
   }
 }

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

@@ -5,6 +5,7 @@ import {
   LibraryBigIcon,
   UserRoundIcon,
   BookAIcon,
+  UsersRoundIcon,
 } from "lucide-react";
 import { requireRole, ROLES } from "@/lib/auth/roles";
 import type { Dictionary, Role, Session } from "@/lib/types";
@@ -98,6 +99,13 @@ export function getMainNavLinks({
       isActive: pathname.startsWith(`/${lang}/catalog`),
       minRole: ROLES.MEMBER,
     },
+    {
+      label: intl.sidebar.clubs as string,
+      href: `/${lang}/clubs`,
+      icon: UsersRoundIcon,
+      isActive: pathname.startsWith(`/${lang}/clubs`),
+      minRole: ROLES.MEMBER,
+    },
     {
       label: intl.sidebar.profile as string,
       href: `/${lang}/profile`,

package/dist/src/lib/types/search.ts

@@ -1,6 +1,6 @@
 export interface SearchResult {
   id: string;
-  section: "manga" | "comic" | "others";
+  section: "manga" | "comic" | "others" | "books";
   type: "series" | "volume";
   title: string;
   slug: string;

package/dist/src/proxies/auth.ts

@@ -20,8 +20,10 @@ export async function authProxy(
   const token = cookiesInstance.get("yomimono_key")?.value;
 
   const isLoginPage = pathname === `/${lang}/login`;
+  const isPublicClubInvitation = pathname.startsWith(`/${lang}/clubs/join/`);
 
   if (!token) {
+    if (isPublicClubInvitation) return null;
     if (!isLoginPage) {
       return NextResponse.redirect(new URL(`/${lang}/login`, request.url));
     }
@@ -34,7 +36,7 @@ export async function authProxy(
       new TextEncoder().encode(process.env.JWT_SECRET)
     );
 
-    if (isLoginPage) {
+    if (isLoginPage && payload.role !== "GUEST") {
       return NextResponse.redirect(new URL(`/${lang}/`, request.url));
     }
 
@@ -43,6 +45,10 @@ export async function authProxy(
       return NextResponse.redirect(new URL(`/${lang}/`, request.url));
     }
 
+    if (payload.role === "GUEST" && !pathname.startsWith(`/${lang}/clubs`)) {
+      return NextResponse.redirect(new URL(`/${lang}/clubs`, request.url));
+    }
+
     return null;
   } catch (err) {
     const response = isLoginPage

package/package.json

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