@itsmrtr/bunkoshelf 1.0.2 → 1.1.1

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

@@ -1,3 +1,5 @@
+import { cacheLife, cacheTag } from "next/cache";
+import { MANGA_LIBRARY_TAG } from "@/lib/mangaLibraryCache";
 import { query, queryOne } from "./query";
 
 export interface GenreFilter {
@@ -98,6 +100,39 @@ export interface LibrarySeriesWithVolumes extends LibrarySeries {
   volumes: LibraryVolume[];
 }
 
+interface SharedVolumeQueryOptions {
+  includeGenres?: boolean;
+  includeTags?: boolean;
+  genreNames?: string[];
+  tagNames?: string[];
+  seriesIds?: string[];
+  volumeIds?: string[];
+}
+
+interface VolumeQueryOptions extends SharedVolumeQueryOptions {
+  userId?: string | null;
+  onlyUnreadForUser?: boolean;
+}
+
+interface SharedSeriesQueryOptions {
+  genreNames?: string[];
+  tagNames?: string[];
+  seriesIds?: string[];
+  includeGenres?: boolean;
+  includeTags?: boolean;
+}
+
+interface FindSeriesOptions {
+  slug: string;
+  includeGenres?: boolean;
+  includeTags?: boolean;
+}
+
+interface FindVolumeOptions extends SharedVolumeQueryOptions {
+  slug: string;
+  userId?: string | null;
+}
+
 interface VolumeRow {
   volume_id: string;
   volume_slug: string;
@@ -406,7 +441,7 @@ function buildVolumeFilterSql(
   return conditions;
 }
 
-export async function listLibraryFilters(): Promise<{
+async function listLibraryFiltersRaw(): Promise<{
   genres: GenreFilter[];
   tags: TagFilter[];
 }> {
@@ -430,16 +465,25 @@ export async function listLibraryFilters(): Promise<{
   return { genres, tags };
 }
 
-export async function listVolumes(options?: {
-  userId?: string | null;
-  includeGenres?: boolean;
-  includeTags?: boolean;
-  genreNames?: string[];
-  tagNames?: string[];
-  seriesIds?: string[];
-  volumeIds?: string[];
-  onlyUnreadForUser?: boolean;
-}): Promise<LibraryVolume[]> {
+async function listLibraryFiltersCached() {
+  "use cache";
+
+  cacheLife("max");
+  cacheTag(MANGA_LIBRARY_TAG);
+
+  return listLibraryFiltersRaw();
+}
+
+export async function listLibraryFilters(): Promise<{
+  genres: GenreFilter[];
+  tags: TagFilter[];
+}> {
+  return listLibraryFiltersCached();
+}
+
+async function listVolumesRaw(
+  options?: VolumeQueryOptions
+): Promise<LibraryVolume[]> {
   const params: unknown[] = [];
   const progressJoin =
     options?.userId
@@ -550,14 +594,36 @@ export async function listVolumes(options?: {
   });
 }
 
-export async function listSeriesWithVolumes(options?: {
-  genreNames?: string[];
-  tagNames?: string[];
-  seriesIds?: string[];
-  includeGenres?: boolean;
-  includeTags?: boolean;
-}): Promise<LibrarySeriesWithVolumes[]> {
-  const volumes = await listVolumes({
+async function listVolumesCached(options: SharedVolumeQueryOptions = {}) {
+  "use cache";
+
+  cacheLife("max");
+  cacheTag(MANGA_LIBRARY_TAG);
+
+  return listVolumesRaw(options);
+}
+
+export async function listVolumes(
+  options?: VolumeQueryOptions
+): Promise<LibraryVolume[]> {
+  if (options?.userId || options?.onlyUnreadForUser) {
+    return listVolumesRaw(options);
+  }
+
+  return listVolumesCached({
+    includeGenres: options?.includeGenres,
+    includeTags: options?.includeTags,
+    genreNames: options?.genreNames,
+    tagNames: options?.tagNames,
+    seriesIds: options?.seriesIds,
+    volumeIds: options?.volumeIds,
+  });
+}
+
+async function listSeriesWithVolumesRaw(
+  options?: SharedSeriesQueryOptions
+): Promise<LibrarySeriesWithVolumes[]> {
+  const volumes = await listVolumesRaw({
     includeGenres: options?.includeGenres,
     includeTags: options?.includeTags,
     genreNames: options?.genreNames,
@@ -584,6 +650,29 @@ export async function listSeriesWithVolumes(options?: {
   return [...seriesMap.values()];
 }
 
+async function listSeriesWithVolumesCached(
+  options: SharedSeriesQueryOptions = {}
+) {
+  "use cache";
+
+  cacheLife("max");
+  cacheTag(MANGA_LIBRARY_TAG);
+
+  return listSeriesWithVolumesRaw(options);
+}
+
+export async function listSeriesWithVolumes(
+  options?: SharedSeriesQueryOptions
+): Promise<LibrarySeriesWithVolumes[]> {
+  return listSeriesWithVolumesCached({
+    genreNames: options?.genreNames,
+    tagNames: options?.tagNames,
+    seriesIds: options?.seriesIds,
+    includeGenres: options?.includeGenres,
+    includeTags: options?.includeTags,
+  });
+}
+
 export async function listSeries(): Promise<LibrarySeries[]> {
   return query<{
     id: string;
@@ -616,11 +705,9 @@ export async function listSeries(): Promise<LibrarySeries[]> {
   );
 }
 
-export async function findSeriesBySlug(options: {
-  slug: string;
-  includeGenres?: boolean;
-  includeTags?: boolean;
-}): Promise<LibrarySeriesWithVolumes | null> {
+async function findSeriesBySlugRaw(
+  options: FindSeriesOptions
+): Promise<LibrarySeriesWithVolumes | null> {
   const row = await queryOne<{ id: string }>(
     `
       SELECT id
@@ -635,7 +722,7 @@ export async function findSeriesBySlug(options: {
     return null;
   }
 
-  const series = await listSeriesWithVolumes({
+  const series = await listSeriesWithVolumesRaw({
     seriesIds: [row.id],
     includeGenres: options.includeGenres,
     includeTags: options.includeTags,
@@ -644,12 +731,24 @@ export async function findSeriesBySlug(options: {
   return series[0] ?? null;
 }
 
-export async function findVolumeBySlug(options: {
-  slug: string;
-  userId?: string | null;
-  includeGenres?: boolean;
-  includeTags?: boolean;
-}): Promise<LibraryVolume | null> {
+async function findSeriesBySlugCached(options: FindSeriesOptions) {
+  "use cache";
+
+  cacheLife("max");
+  cacheTag(MANGA_LIBRARY_TAG);
+
+  return findSeriesBySlugRaw(options);
+}
+
+export async function findSeriesBySlug(
+  options: FindSeriesOptions
+): Promise<LibrarySeriesWithVolumes | null> {
+  return findSeriesBySlugCached(options);
+}
+
+async function findVolumeBySlugRaw(
+  options: FindVolumeOptions
+): Promise<LibraryVolume | null> {
   const row = await queryOne<{ id: string }>(
     `
       SELECT id
@@ -664,7 +763,7 @@ export async function findVolumeBySlug(options: {
     return null;
   }
 
-  const volumes = await listVolumes({
+  const volumes = await listVolumesRaw({
     volumeIds: [row.id],
     userId: options.userId,
     includeGenres: options.includeGenres,
@@ -674,6 +773,29 @@ export async function findVolumeBySlug(options: {
   return volumes[0] ?? null;
 }
 
+async function findVolumeBySlugCached(options: FindSeriesOptions) {
+  "use cache";
+
+  cacheLife("max");
+  cacheTag(MANGA_LIBRARY_TAG);
+
+  return findVolumeBySlugRaw(options);
+}
+
+export async function findVolumeBySlug(
+  options: FindVolumeOptions
+): Promise<LibraryVolume | null> {
+  if (options.userId) {
+    return findVolumeBySlugRaw(options);
+  }
+
+  return findVolumeBySlugCached({
+    slug: options.slug,
+    includeGenres: options.includeGenres,
+    includeTags: options.includeTags,
+  });
+}
+
 export async function findVolumePageCountById(
   volumeId: string
 ): Promise<number | null> {

package/dist/src/lib/db/migrations/002_add_profile_image_to_users.sql

@@ -0,0 +1,2 @@
+ALTER TABLE users
+ADD COLUMN IF NOT EXISTS profile_image TEXT;

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

@@ -10,6 +10,7 @@ export interface UserRow {
   name: string | null;
   lastname: string | null;
   birth_year: number | null;
+  profile_image: string | null;
 }
 
 export interface PublicUser {
@@ -20,4 +21,5 @@ export interface PublicUser {
   name: string | null;
   lastname: string | null;
   birthYear: number | null;
+  profileImage: string | null;
 }

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

@@ -11,6 +11,7 @@ function mapUser(row: UserRow): PublicUser {
     name: row.name,
     lastname: row.lastname,
     birthYear: row.birth_year,
+    profileImage: row.profile_image,
   };
 }
 
@@ -31,6 +32,7 @@ export async function findUserByUsername(
   const row = await queryOne<UserRow>(
     `
       SELECT id, created_at, username, password, is_admin, role, name, lastname, birth_year
+      , profile_image
       FROM users
       WHERE username = $1
       LIMIT 1
@@ -45,6 +47,7 @@ export async function findUserSessionById(id: string): Promise<PublicUser | null
   const row = await queryOne<UserRow>(
     `
       SELECT id, created_at, username, password, is_admin, role, name, lastname, birth_year
+      , profile_image
       FROM users
       WHERE id = $1
       LIMIT 1
@@ -58,6 +61,7 @@ export async function findUserSessionById(id: string): Promise<PublicUser | null
 export async function listUsers(): Promise<PublicUser[]> {
   const rows = await query<UserRow>(`
     SELECT id, created_at, username, password, is_admin, role, name, lastname, birth_year
+    , profile_image
     FROM users
     ORDER BY COALESCE(name, username) ASC, username ASC
   `);
@@ -119,10 +123,11 @@ export async function createUserRecord(
         role,
         name,
         lastname,
-        birth_year
+        birth_year,
+        profile_image
       )
-      VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
-      RETURNING id, created_at, username, password, is_admin, role, name, lastname, birth_year
+      VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+      RETURNING id, created_at, username, password, is_admin, role, name, lastname, birth_year, profile_image
     `,
     [
       crypto.randomUUID(),
@@ -133,6 +138,7 @@ export async function createUserRecord(
       input.name ?? null,
       input.lastname ?? null,
       input.birthYear ?? null,
+      null,
     ]
   );
 
@@ -153,6 +159,7 @@ export async function updateUserRecord(
     birthYear?: number | null;
     isAdmin?: boolean;
     role?: Role;
+    profileImage?: string | null;
   }
 ): Promise<PublicUser | null> {
   const assignments: string[] = [];
@@ -193,6 +200,11 @@ export async function updateUserRecord(
     assignments.push(`role = $${values.length}`);
   }
 
+  if (input.profileImage !== undefined) {
+    values.push(input.profileImage);
+    assignments.push(`profile_image = $${values.length}`);
+  }
+
   if (assignments.length === 0) {
     return findUserSessionById(id);
   }
@@ -204,7 +216,7 @@ export async function updateUserRecord(
       UPDATE users
       SET ${assignments.join(", ")}
       WHERE id = $${values.length}
-      RETURNING id, created_at, username, password, is_admin, role, name, lastname, birth_year
+      RETURNING id, created_at, username, password, is_admin, role, name, lastname, birth_year, profile_image
     `,
     values
   );

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

@@ -5,6 +5,9 @@
     "name": "Name",
     "lastname": "Lastname",
     "password": "New Password",
+    "picture": "Profile picture",
+    "pictureHelp": "PNG, JPG or WEBP. Max 5MB.",
+    "removePicture": "Remove profile picture",
     "save": "Save Changes",
     "greeting": "Hi,",
     "updateProfile": "Update Profile",

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

@@ -5,6 +5,9 @@
     "name": "Nombre",
     "lastname": "Apellido",
     "password": "Nueva contraseña",
+    "picture": "Foto de perfil",
+    "pictureHelp": "PNG, JPG o WEBP. Máximo 5MB.",
+    "removePicture": "Eliminar foto de perfil",
     "save": "Guardar cambios",
     "greeting": "Hola,",
     "updateProfile": "Actualizar perfil",

package/dist/src/lib/mangaCover.ts

@@ -0,0 +1,35 @@
+interface MangaCoverInput {
+  slug: string;
+  coverImage: string | null;
+  updatedAt?: Date | string | null;
+}
+
+function getVersion(updatedAt?: Date | string | null): string | null {
+  if (!updatedAt) {
+    return null;
+  }
+
+  const date = updatedAt instanceof Date ? updatedAt : new Date(updatedAt);
+  const timestamp = date.getTime();
+
+  if (Number.isNaN(timestamp)) {
+    return null;
+  }
+
+  return String(timestamp);
+}
+
+export function getMangaCoverUrl({
+  slug,
+  coverImage,
+  updatedAt,
+}: MangaCoverInput): string | null {
+  if (!coverImage) {
+    return null;
+  }
+
+  const version = getVersion(updatedAt);
+  const query = version ? `?v=${version}` : "";
+
+  return `/api/library/manga/cover/${slug}/${coverImage}${query}`;
+}

package/dist/src/lib/mangaLibraryCache.ts

@@ -0,0 +1,7 @@
+import { revalidateTag } from "next/cache";
+
+export const MANGA_LIBRARY_TAG = "manga-library";
+
+export function revalidateMangaLibraryCache() {
+  revalidateTag(MANGA_LIBRARY_TAG, "max");
+}

package/dist/src/lib/profileImage.ts

@@ -0,0 +1,141 @@
+import path from "path";
+import fs from "fs/promises";
+import {
+  DeleteObjectCommand,
+  GetObjectCommand,
+  PutObjectCommand,
+} from "@aws-sdk/client-s3";
+import r2Client, { R2_BUCKET } from "@/lib/r2";
+const LIB_PROVIDER = process.env.LIB_PROVIDER || "local";
+const PROFILE_ROOT_DIR = "profile";
+const PROFILE_LOCAL_DIR = path.resolve(process.cwd(), "..", PROFILE_ROOT_DIR);
+const PROFILE_MAX_SIZE_BYTES = 5 * 1024 * 1024;
+
+const PROFILE_MIME_TYPES: Record<string, string> = {
+  "image/jpeg": ".jpg",
+  "image/png": ".png",
+  "image/webp": ".webp",
+};
+
+export function validateProfileImage(file: File): string | null {
+  if (!(file.type in PROFILE_MIME_TYPES)) {
+    return "Invalid image type";
+  }
+
+  if (file.size > PROFILE_MAX_SIZE_BYTES) {
+    return "Image too large";
+  }
+
+  return null;
+}
+
+function getProfileImageExtension(file: File): string {
+  const extensionFromMime = PROFILE_MIME_TYPES[file.type];
+
+  if (extensionFromMime) {
+    return extensionFromMime;
+  }
+
+  const extensionFromName = path.extname(file.name).toLowerCase();
+  return extensionFromName || ".jpg";
+}
+
+function buildProfileImageFilename(userId: string, file: File): string {
+  const extension = getProfileImageExtension(file);
+  return `${userId}-${crypto.randomUUID()}${extension}`;
+}
+
+function buildProfileImageKey(filename: string): string {
+  return `${PROFILE_ROOT_DIR}/${filename}`;
+}
+
+export async function saveProfileImage(file: File, userId: string): Promise<string> {
+  const filename = buildProfileImageFilename(userId, file);
+  const key = buildProfileImageKey(filename);
+  const buffer = Buffer.from(await file.arrayBuffer());
+
+  if (LIB_PROVIDER === "cloud") {
+    await r2Client.send(
+      new PutObjectCommand({
+        Bucket: R2_BUCKET,
+        Key: key,
+        Body: buffer,
+        ContentType: file.type,
+      })
+    );
+
+    return filename;
+  }
+
+  await fs.mkdir(PROFILE_LOCAL_DIR, { recursive: true });
+  await fs.writeFile(path.join(PROFILE_LOCAL_DIR, filename), buffer);
+
+  return filename;
+}
+
+export async function deleteProfileImage(filename: string | null | undefined): Promise<void> {
+  if (!filename) return;
+
+  if (LIB_PROVIDER === "cloud") {
+    await r2Client.send(
+      new DeleteObjectCommand({
+        Bucket: R2_BUCKET,
+        Key: buildProfileImageKey(filename),
+      })
+    );
+    return;
+  }
+
+  await fs.rm(path.join(PROFILE_LOCAL_DIR, filename), { force: true });
+}
+
+export async function readProfileImage(filename: string): Promise<Response | null> {
+  try {
+    if (LIB_PROVIDER === "cloud") {
+      const response = await r2Client.send(
+        new GetObjectCommand({
+          Bucket: R2_BUCKET,
+          Key: buildProfileImageKey(filename),
+        })
+      );
+
+      const bytes = await response.Body?.transformToByteArray();
+
+      if (!bytes) return null;
+
+      return new Response(Buffer.from(bytes), {
+        headers: {
+          "Content-Type": response.ContentType || getContentType(filename),
+          "Cache-Control": "public, max-age=31536000, immutable",
+        },
+      });
+    }
+
+    const file = await fs.readFile(path.join(PROFILE_LOCAL_DIR, filename));
+
+    return new Response(file, {
+      headers: {
+        "Content-Type": getContentType(filename),
+        "Cache-Control": "public, max-age=31536000, immutable",
+      },
+    });
+  } catch {
+    return null;
+  }
+}
+
+function getContentType(filePath: string): string {
+  const ext = path.extname(filePath).toLowerCase();
+
+  switch (ext) {
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".png":
+      return "image/png";
+    case ".webp":
+      return "image/webp";
+    default:
+      return "application/octet-stream";
+  }
+}

package/dist/src/lib/profileImageUrl.ts

@@ -0,0 +1,4 @@
+export function getProfileImageUrl(filename: string | null | undefined): string | null {
+  if (!filename) return null;
+  return `/api/profile/${encodeURIComponent(filename)}`;
+}

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

@@ -8,6 +8,7 @@ export interface Session {
   name: string | null;
   lastname: string | null;
   birthYear: number | null;
+  profileImage: string | null;
 }
 
 export type Permission =

package/dist/src/lib/versionInfo.ts

@@ -4,7 +4,7 @@ const PACKAGE_NAME = "@itsmrtr/bunkoshelf";
 const REPOSITORY_URL = "https://github.com/martirale/bunkoshelf";
 const RELEASES_URL = `${REPOSITORY_URL}/releases`;
 const REGISTRY_URL = `https://registry.npmjs.org/${encodeURIComponent(PACKAGE_NAME)}/latest`;
-const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+const CACHE_TTL_MS = 6 * 60 * 60 * 1000;
 
 export interface VersionInfo {
   currentVersion: string;

package/package.json

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

package/runtime/cli.mjs

@@ -1,9 +1,30 @@
 const [, , command, ...args] = process.argv;
 
+function parseInitArgs(rawArgs) {
+  const options = {
+    cloud: false,
+  };
+  let projectName;
+
+  for (const arg of rawArgs) {
+    if (arg === "--cloud") {
+      options.cloud = true;
+      continue;
+    }
+
+    if (!projectName) {
+      projectName = arg;
+    }
+  }
+
+  return { projectName, options };
+}
+
 switch (command) {
   case "init": {
     const { init } = await import("./commands/init.mjs");
-    await init(args[0]);
+    const { projectName, options } = parseInitArgs(args);
+    await init(projectName, options);
     break;
   }
   case "start": {
@@ -19,7 +40,8 @@ switch (command) {
   default:
     if (command && !command.startsWith("-")) {
       const { init } = await import("./commands/init.mjs");
-      await init(command);
+      const { options } = parseInitArgs(args);
+      await init(command, options);
     } else {
       console.error("Usage: bunkoshelf <init|start|update> [project-name|version]");
       process.exit(1);

package/runtime/commands/init.mjs

@@ -15,17 +15,25 @@ function generateSecret() {
   return randomBytes(32).toString("hex");
 }
 
-function buildEnv(jwtSecret) {
-  return [
+export function buildEnv(jwtSecret, provider = "local") {
+  const lines = [
     "DATABASE_URL=postgresql://user:password@localhost:5432/bunkoshelf",
     `JWT_SECRET=${jwtSecret}`,
     `PORT=${DEFAULT_PORT}`,
     `SITE_URL=http://localhost:${DEFAULT_PORT}`,
-    "LIB_PROVIDER=local",
-    "VAPID_PUBLIC_KEY=",
-    "PUSH_SERVER_URL=",
-    "PUSH_API_KEY=",
-  ].join("\n") + "\n";
+    `LIB_PROVIDER=${provider}`,
+  ];
+
+  if (provider === "cloud") {
+    lines.push(
+      "R2_ENDPOINT=",
+      "R2_ACCESS_KEY_ID=",
+      "R2_SECRET_ACCESS_KEY=",
+      "R2_BUCKET_NAME=bunko-shelf "
+    );
+  }
+
+  return lines.join("\n") + "\n";
 }
 
 function buildPackageJson(name) {
@@ -43,8 +51,9 @@ function buildPackageJson(name) {
   };
 }
 
-export async function init(projectName) {
+export async function init(projectName, options = {}) {
   intro(chalk.bold("▲ Bunko Shelf"));
+  const provider = options.cloud ? "cloud" : "local";
 
   const useCurrentDir = projectName === ".";
   let name = useCurrentDir ? undefined : projectName;
@@ -88,7 +97,7 @@ export async function init(projectName) {
 
   progress.start("Creating project...");
   await fs.ensureDir(projectDir);
-  await fs.writeFile(join(projectDir, ".env"), buildEnv(generateSecret()));
+  await fs.writeFile(join(projectDir, ".env"), buildEnv(generateSecret(), provider));
   await fs.writeJson(join(projectDir, "package.json"), buildPackageJson(name), {
     spaces: 2,
   });