cyreader 0.1.0

package/bundle/server/dist/reading/recent/service.test.js

@@ -0,0 +1,84 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { NotFoundError } from '../../library/errors.js';
+import { LibraryService } from '../../library/service.js';
+import { MAX_RECENT } from './schema.js';
+import { RecentService } from './service.js';
+import { readRecentStoreFromDisk } from './storage.js';
+describe('RecentService', () => {
+    let tempDir;
+    let previousConfigDir;
+    let novelRoot;
+    let libraryService;
+    let recentService;
+    let novelId;
+    beforeEach(async () => {
+        previousConfigDir = process.env.CYREADER_CONFIG_DIR;
+        tempDir = await mkdtemp(path.join(tmpdir(), 'cyreader-recent-service-'));
+        process.env.CYREADER_CONFIG_DIR = tempDir;
+        novelRoot = path.join(tempDir, 'novels');
+        await mkdir(novelRoot);
+        await Promise.all(Array.from({ length: MAX_RECENT + 2 }, (_, index) => writeFile(path.join(novelRoot, `book-${index}.txt`), 'content')));
+        libraryService = new LibraryService(() => ({
+            novelDirectories: [{ id: 'novel-root', path: novelRoot }],
+            comicDirectories: [],
+            gbkNovelHandling: 'ignore',
+        }));
+        await libraryService.scan();
+        novelId = libraryService.getState().items[0].id;
+        recentService = await RecentService.create(libraryService);
+    });
+    afterEach(async () => {
+        if (previousConfigDir === undefined) {
+            delete process.env.CYREADER_CONFIG_DIR;
+        }
+        else {
+            process.env.CYREADER_CONFIG_DIR = previousConfigDir;
+        }
+        await rm(tempDir, { recursive: true, force: true });
+    });
+    it('records open and moves existing item to front', async () => {
+        const secondId = libraryService.getState().items[1].id;
+        await recentService.recordOpen(novelId);
+        await recentService.recordOpen(secondId);
+        await recentService.recordOpen(novelId);
+        const items = await recentService.getRecentItems();
+        expect(items.map((item) => item.id)).toEqual([novelId, secondId]);
+        const store = await readRecentStoreFromDisk();
+        expect(store.recent[0]?.itemId).toBe(novelId);
+        expect(store.recent[0]?.openedAt).toBe(items[0]?.openedAt);
+    });
+    it('truncates to MAX_RECENT entries', async () => {
+        const ids = libraryService.getState().items.map((item) => item.id);
+        await ids.reduce(async (previous, id) => {
+            await previous;
+            await recentService.recordOpen(id);
+        }, Promise.resolve());
+        const store = await readRecentStoreFromDisk();
+        expect(store.recent).toHaveLength(MAX_RECENT);
+        const items = await recentService.getRecentItems();
+        expect(items).toHaveLength(MAX_RECENT);
+    });
+    it('removes stale entries when getting recent items', async () => {
+        await recentService.recordOpen(novelId);
+        const missingId = 'missing-item-id';
+        const store = await readRecentStoreFromDisk();
+        const { writeRecentStore } = await import('./storage.js');
+        await writeRecentStore({
+            recent: [
+                { itemId: missingId, type: 'novel', openedAt: '2026-06-12T09:00:00.000Z' },
+                ...store.recent,
+            ],
+        });
+        const items = await recentService.getRecentItems();
+        expect(items.every((item) => item.id !== missingId)).toBe(true);
+        expect(items.some((item) => item.id === novelId)).toBe(true);
+        const cleaned = await readRecentStoreFromDisk();
+        expect(cleaned.recent.every((entry) => entry.itemId !== missingId)).toBe(true);
+    });
+    it('throws when recording unknown item', async () => {
+        await expect(recentService.recordOpen('missing')).rejects.toBeInstanceOf(NotFoundError);
+    });
+});

package/bundle/server/dist/reading/recent/storage.js

@@ -0,0 +1,42 @@
+import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { getConfigDir, getRecentFilePath } from '../../config/paths.js';
+import { createEmptyRecentStore, parseRecentStore } from './schema.js';
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function writeRecentStore(store) {
+    const configDir = getConfigDir();
+    const recentFile = getRecentFilePath();
+    const normalized = parseRecentStore(store);
+    await mkdir(configDir, { recursive: true });
+    await writeFile(recentFile, `${JSON.stringify(normalized, null, 2)}\n`, 'utf-8');
+}
+export async function readRecentStoreFromDisk() {
+    const recentFile = getRecentFilePath();
+    const content = await readFile(recentFile, 'utf-8');
+    let data;
+    try {
+        data = JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse recent file: ${recentFile}`, { cause: error });
+    }
+    return parseRecentStore(data);
+}
+export async function ensureRecentStore() {
+    const configDir = getConfigDir();
+    const recentFile = getRecentFilePath();
+    await mkdir(configDir, { recursive: true });
+    if (!(await fileExists(recentFile))) {
+        const empty = createEmptyRecentStore();
+        await writeRecentStore(empty);
+        return empty;
+    }
+    return readRecentStoreFromDisk();
+}

package/bundle/server/dist/reading/recent/storage.test.js

@@ -0,0 +1,46 @@
+import { access, mkdtemp, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { getRecentFilePath } from '../../config/paths.js';
+import { ensureRecentStore, readRecentStoreFromDisk, writeRecentStore } from './storage.js';
+describe('recent storage', () => {
+    let tempDir;
+    let previousConfigDir;
+    beforeEach(async () => {
+        previousConfigDir = process.env.CYREADER_CONFIG_DIR;
+        tempDir = await mkdtemp(path.join(tmpdir(), 'cyreader-recent-'));
+        process.env.CYREADER_CONFIG_DIR = tempDir;
+    });
+    afterEach(async () => {
+        if (previousConfigDir === undefined) {
+            delete process.env.CYREADER_CONFIG_DIR;
+        }
+        else {
+            process.env.CYREADER_CONFIG_DIR = previousConfigDir;
+        }
+        await rm(tempDir, { recursive: true, force: true });
+    });
+    it('creates recent file when missing', async () => {
+        const store = await ensureRecentStore();
+        const recentFile = getRecentFilePath();
+        expect(store).toEqual({ recent: [] });
+        await expect(access(recentFile)).resolves.toBeUndefined();
+        const content = await readFile(recentFile, 'utf-8');
+        expect(JSON.parse(content)).toEqual({ recent: [] });
+    });
+    it('reads and writes recent store', async () => {
+        await ensureRecentStore();
+        const payload = {
+            recent: [
+                {
+                    itemId: 'abc123',
+                    type: 'novel',
+                    openedAt: '2026-06-12T10:00:00.000Z',
+                },
+            ],
+        };
+        await writeRecentStore(payload);
+        await expect(readRecentStoreFromDisk()).resolves.toEqual(payload);
+    });
+});

package/bundle/server/dist/routes/config.js

@@ -0,0 +1,52 @@
+import { Hono } from 'hono';
+import { ZodError } from 'zod';
+import { formatZodError } from '../config/schema.js';
+export function createConfigRoutes(configService, libraryService, options) {
+    const routes = new Hono();
+    routes.get('/', (c) => {
+        return c.json(configService.get());
+    });
+    routes.put('/', async (c) => {
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: 'Invalid JSON body' }, 400);
+        }
+        try {
+            const config = await configService.replace(body);
+            options?.onConfigChange?.();
+            libraryService?.tryScan();
+            return c.json(config);
+        }
+        catch (error) {
+            if (error instanceof ZodError) {
+                return c.json(formatZodError(error), 400);
+            }
+            throw error;
+        }
+    });
+    routes.patch('/', async (c) => {
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: 'Invalid JSON body' }, 400);
+        }
+        try {
+            const config = await configService.patch(body);
+            options?.onConfigChange?.();
+            libraryService?.tryScan();
+            return c.json(config);
+        }
+        catch (error) {
+            if (error instanceof ZodError) {
+                return c.json(formatZodError(error), 400);
+            }
+            throw error;
+        }
+    });
+    return routes;
+}

package/bundle/server/dist/routes/config.test.js

@@ -0,0 +1,147 @@
+import { access, mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { createApp } from '../app.js';
+import { ConfigService } from '../config/service.js';
+import { LibraryService } from '../library/service.js';
+import { ProgressService } from '../reading/progress/service.js';
+import { RecentService } from '../reading/recent/service.js';
+function directory(id, directoryPath) {
+    return { id, path: directoryPath };
+}
+describe('config routes', () => {
+    let tempDir;
+    let previousConfigDir;
+    let configService;
+    let libraryService;
+    let app;
+    beforeEach(async () => {
+        previousConfigDir = process.env.CYREADER_CONFIG_DIR;
+        tempDir = await mkdtemp(path.join(tmpdir(), 'cyreader-routes-'));
+        process.env.CYREADER_CONFIG_DIR = tempDir;
+        configService = await ConfigService.create();
+        libraryService = new LibraryService(() => configService.get());
+        const recentService = await RecentService.create(libraryService);
+        const progressService = await ProgressService.create(libraryService);
+        app = createApp(configService, libraryService, recentService, progressService);
+    });
+    afterEach(async () => {
+        if (previousConfigDir === undefined) {
+            delete process.env.CYREADER_CONFIG_DIR;
+        }
+        else {
+            process.env.CYREADER_CONFIG_DIR = previousConfigDir;
+        }
+        await rm(tempDir, { recursive: true, force: true });
+    });
+    it('GET /api/config returns current config', async () => {
+        const res = await app.request('/api/config');
+        expect(res.status).toBe(200);
+        expect(await res.json()).toEqual({
+            novelDirectories: [],
+            comicDirectories: [],
+            gbkNovelHandling: 'ignore',
+        });
+    });
+    it('PUT /api/config replaces and persists config', async () => {
+        const novelDir = path.join(tempDir, 'novels');
+        const comicDir = path.join(tempDir, 'comics');
+        const body = {
+            novelDirectories: [directory('novel-1', novelDir)],
+            comicDirectories: [directory('comic-1', comicDir)],
+        };
+        const res = await app.request('/api/config', {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        expect(res.status).toBe(200);
+        const expected = { ...body, gbkNovelHandling: 'ignore' };
+        expect(await res.json()).toEqual(expected);
+        expect(configService.get()).toEqual(expected);
+        const getRes = await app.request('/api/config');
+        expect(await getRes.json()).toEqual(expected);
+        await expect(access(novelDir)).resolves.toBeUndefined();
+        await expect(access(comicDir)).resolves.toBeUndefined();
+    });
+    it('PATCH /api/config updates only provided fields', async () => {
+        const novelDir = path.join(tempDir, 'novels');
+        await app.request('/api/config', {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                novelDirectories: [directory('novel-1', novelDir)],
+                comicDirectories: [],
+            }),
+        });
+        const comicDir = path.join(tempDir, 'comics');
+        const res = await app.request('/api/config', {
+            method: 'PATCH',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                comicDirectories: [directory('comic-1', comicDir)],
+            }),
+        });
+        expect(res.status).toBe(200);
+        expect(await res.json()).toEqual({
+            novelDirectories: [directory('novel-1', novelDir)],
+            comicDirectories: [directory('comic-1', comicDir)],
+            gbkNovelHandling: 'ignore',
+        });
+    });
+    it('PUT /api/config rejects duplicate directory paths with 400', async () => {
+        const novelDir = path.join(tempDir, 'novels');
+        const res = await app.request('/api/config', {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                novelDirectories: [directory('novel-1', novelDir), directory('novel-2', novelDir)],
+                comicDirectories: [],
+            }),
+        });
+        expect(res.status).toBe(400);
+        const body = await res.json();
+        expect(body.error).toBe('Validation failed');
+        expect(body.details[0]?.message).toBe('Directory path must be unique');
+    });
+    it('PUT /api/config rejects relative paths with 400', async () => {
+        const res = await app.request('/api/config', {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                novelDirectories: [directory('novel-1', 'relative/novels')],
+                comicDirectories: [],
+            }),
+        });
+        expect(res.status).toBe(400);
+        const body = await res.json();
+        expect(body.error).toBe('Validation failed');
+        expect(body.details[0]?.message).toContain('absolute');
+    });
+    it('PATCH /api/config rejects relative paths with 400', async () => {
+        const res = await app.request('/api/config', {
+            method: 'PATCH',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                novelDirectories: [directory('novel-1', './novels')],
+            }),
+        });
+        expect(res.status).toBe(400);
+        const body = await res.json();
+        expect(body.error).toBe('Validation failed');
+        expect(body.details[0]?.message).toContain('absolute');
+    });
+    it('PUT /api/config rejects invalid body with 400', async () => {
+        const res = await app.request('/api/config', {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                novelDirectories: 'not-an-array',
+                comicDirectories: [],
+            }),
+        });
+        expect(res.status).toBe(400);
+        expect((await res.json()).error).toBe('Validation failed');
+    });
+});

package/bundle/server/dist/routes/library.js

@@ -0,0 +1,31 @@
+import { Hono } from 'hono';
+import { NotFoundError } from '../library/errors.js';
+export function createLibraryRoutes(libraryService, progressService) {
+    const routes = new Hono();
+    routes.get('/', async (c) => {
+        const progressMap = await progressService.getProgressMap();
+        return c.json(libraryService.getState(progressMap));
+    });
+    routes.get('/:id', async (c) => {
+        const id = c.req.param('id');
+        try {
+            const progressMap = await progressService.getProgressMap();
+            const detail = libraryService.getItemDetail(id, progressMap);
+            return c.json(detail);
+        }
+        catch (error) {
+            if (error instanceof NotFoundError) {
+                return c.json({ error: error.message }, 404);
+            }
+            throw error;
+        }
+    });
+    routes.post('/scan', (c) => {
+        if (libraryService.isScanning()) {
+            return c.json({ error: 'Scan already in progress' }, 409);
+        }
+        libraryService.tryScan();
+        return c.body(null, 202);
+    });
+    return routes;
+}

package/bundle/server/dist/routes/library.test.js

@@ -0,0 +1,125 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { createApp } from '../app.js';
+import { ConfigService } from '../config/service.js';
+import { LibraryService } from '../library/service.js';
+import { writeTestImage } from '../library/test-images.js';
+import { ProgressService } from '../reading/progress/service.js';
+import { RecentService } from '../reading/recent/service.js';
+describe('library routes', () => {
+    let tempDir;
+    let previousConfigDir;
+    let configService;
+    let libraryService;
+    let app;
+    let novelRoot;
+    let comicRoot;
+    let mangaDir;
+    beforeEach(async () => {
+        previousConfigDir = process.env.CYREADER_CONFIG_DIR;
+        tempDir = await mkdtemp(path.join(tmpdir(), 'cyreader-library-routes-'));
+        process.env.CYREADER_CONFIG_DIR = tempDir;
+        novelRoot = path.join(tempDir, 'novels');
+        comicRoot = path.join(tempDir, 'comics');
+        mangaDir = path.join(comicRoot, 'manga');
+        await mkdir(novelRoot);
+        await mkdir(mangaDir, { recursive: true });
+        await writeFile(path.join(novelRoot, 'book.txt'), 'chapter one\n\nchapter two');
+        await writeTestImage(path.join(mangaDir, '1.jpg'), 300, 400);
+        await writeTestImage(path.join(mangaDir, '2.jpg'), 300, 400);
+        configService = await ConfigService.create();
+        await configService.replace({
+            novelDirectories: [{ id: 'novel-root', path: novelRoot }],
+            comicDirectories: [{ id: 'comic-root', path: comicRoot }],
+        });
+        libraryService = new LibraryService(() => configService.get());
+        const recentService = await RecentService.create(libraryService);
+        const progressService = await ProgressService.create(libraryService);
+        app = createApp(configService, libraryService, recentService, progressService);
+        await libraryService.scan();
+    });
+    afterEach(async () => {
+        if (previousConfigDir === undefined) {
+            delete process.env.CYREADER_CONFIG_DIR;
+        }
+        else {
+            process.env.CYREADER_CONFIG_DIR = previousConfigDir;
+        }
+        await rm(tempDir, { recursive: true, force: true });
+    });
+    it('GET /api/library returns scanning state and list items', async () => {
+        const res = await app.request('/api/library');
+        expect(res.status).toBe(200);
+        const body = await res.json();
+        expect(body.scanning).toBe(false);
+        expect(body.items).toEqual(expect.arrayContaining([
+            {
+                id: expect.any(String),
+                type: 'novel',
+                title: 'book',
+                progress: null,
+            },
+            {
+                id: expect.any(String),
+                type: 'comic',
+                title: 'manga',
+                cover: expect.stringMatching(/^\/static\/comic-root\/manga\/cover\.jpg$/),
+                pageCount: 2,
+                progress: null,
+            },
+        ]));
+        expect(body.items).not.toEqual(expect.arrayContaining([expect.objectContaining({ path: expect.any(String) })]));
+    });
+    it('GET /api/library/:id returns novel detail', async () => {
+        const novel = libraryService.getState().items.find((item) => item.type === 'novel');
+        const res = await app.request(`/api/library/${novel.id}`);
+        expect(res.status).toBe(200);
+        expect(await res.json()).toEqual({
+            id: novel.id,
+            type: 'novel',
+            title: 'book',
+            directoryId: 'novel-root',
+            filename: 'book.txt',
+            progress: null,
+        });
+    });
+    it('serves novel content via static URL', async () => {
+        const novel = libraryService.getState().items.find((item) => item.type === 'novel');
+        const detailRes = await app.request(`/api/library/${novel.id}`);
+        const detail = (await detailRes.json());
+        const contentRes = await app.request(`/static/${detail.directoryId}/${detail.filename}`);
+        expect(contentRes.status).toBe(200);
+        expect(await contentRes.text()).toBe('chapter one\n\nchapter two');
+        expect(contentRes.headers.get('content-type')).toBe('text/plain; charset=utf-8');
+    });
+    it('GET /api/library/:id returns comic detail', async () => {
+        const comic = libraryService.getState().items.find((item) => item.type === 'comic');
+        const res = await app.request(`/api/library/${comic.id}`);
+        expect(res.status).toBe(200);
+        expect(await res.json()).toEqual({
+            id: comic.id,
+            type: 'comic',
+            title: 'manga',
+            directoryId: 'comic-root',
+            pages: ['1.jpg', '2.jpg'],
+            progress: null,
+        });
+    });
+    it('GET /api/library/:id returns 404 for unknown item', async () => {
+        const res = await app.request('/api/library/unknown');
+        expect(res.status).toBe(404);
+        expect(await res.json()).toEqual({ error: 'Item not found' });
+    });
+    it('POST /api/library/scan returns 202 and starts scan', async () => {
+        const res = await app.request('/api/library/scan', { method: 'POST' });
+        expect(res.status).toBe(202);
+    });
+    it('POST /api/library/scan returns 409 when scan is in progress', async () => {
+        vi.spyOn(libraryService, 'isScanning').mockReturnValue(true);
+        const res = await app.request('/api/library/scan', { method: 'POST' });
+        expect(res.status).toBe(409);
+        expect(await res.json()).toEqual({ error: 'Scan already in progress' });
+    });
+});

package/bundle/server/dist/routes/reading.js

@@ -0,0 +1,66 @@
+import { Hono } from 'hono';
+import { z } from 'zod';
+import { NotFoundError } from '../library/errors.js';
+import { progressInputSchema } from '../reading/progress/schema.js';
+const recordRecentBodySchema = z.object({
+    itemId: z.string().min(1),
+});
+export function createReadingRoutes(recentService, progressService) {
+    const routes = new Hono();
+    routes.get('/recent', async (c) => {
+        const progressMap = await progressService.getProgressMap();
+        const items = await recentService.getRecentItems(progressMap);
+        return c.json({ items });
+    });
+    routes.post('/recent', async (c) => {
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: 'Invalid JSON body' }, 400);
+        }
+        const parsed = recordRecentBodySchema.safeParse(body);
+        if (!parsed.success) {
+            return c.json({ error: 'Validation failed' }, 400);
+        }
+        try {
+            await recentService.recordOpen(parsed.data.itemId);
+            return c.body(null, 204);
+        }
+        catch (error) {
+            if (error instanceof NotFoundError) {
+                return c.json({ error: error.message }, 404);
+            }
+            throw error;
+        }
+    });
+    routes.put('/progress/:itemId', async (c) => {
+        const itemId = c.req.param('itemId');
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: 'Invalid JSON body' }, 400);
+        }
+        const parsed = progressInputSchema.safeParse(body);
+        if (!parsed.success) {
+            return c.json({ error: 'Validation failed' }, 400);
+        }
+        try {
+            const entry = await progressService.saveProgress(itemId, parsed.data);
+            return c.json(entry);
+        }
+        catch (error) {
+            if (error instanceof NotFoundError) {
+                return c.json({ error: error.message }, 404);
+            }
+            if (error instanceof TypeError) {
+                return c.json({ error: error.message }, 400);
+            }
+            throw error;
+        }
+    });
+    return routes;
+}