fix: 批次任务随批次保留清理，未完成批次始终可见，默认读取不加载整页图片

- 已保存任务的 7 天清理只针对单独上传的任务；批次中的题随批次保留，全部入库超过保留期后连同批次一起清理
- 批次列表分开查询：未完成的批次全部返回，已完成的只列最近 10 个，较新的已完成批次不会挤掉更早的草稿
- 批次读取默认不从数据库读出整页图片，只有预览页明确取图或后台分题时读取

Author: margrop

src/__tests__/integration/import-batches.test.ts

@@ -58,7 +58,8 @@ import { POST as CONFIRM_TASK } from '@/app/api/import-tasks/[id]/confirm/route'
 import { waitForImportBatchTasksForTest } from '@/lib/import-batches';
 import { simulateRestartForTest, waitForImportTaskForTest } from '@/lib/import-tasks';
 
-let database: PrismaClient;
+let database: PrismaClient<{ log: Array<{ emit: 'event'; level: 'query' }> }>;
+const queries: string[] = [];
 let directory: string;
 let sequence = 0;
 const PAGE = 'data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAA==';
@@ -109,7 +110,9 @@ beforeAll(async () => {
     execFileSync(process.execPath, [resolve('node_modules/prisma/build/index.js'), 'migrate', 'deploy'], {
         env: { ...process.env, DATABASE_URL: url }, stdio: 'pipe',
     });
-    database = new PrismaClient({ datasources: { db: { url } } });
+    database = new PrismaClient({ datasources: { db: { url } }, log: [{ emit: 'event', level: 'query' }] });
+    // 记录执行的 SQL，用于检查默认读取是否带出整页图片
+    database.$on('query', (event) => { queries.push(event.query); });
     await database.$queryRaw`PRAGMA journal_mode = WAL`;
     await database.$queryRaw`PRAGMA busy_timeout = 30000`;
     mocks.prisma = database;
@@ -437,6 +440,68 @@ describe('照片自动分题批次', () => {
     });
 });
 
+describe('批次生命周期', () => {
+    const DAY = 24 * 60 * 60 * 1000;
+
+    it('批次中 7 天前已保存的题在批次未完成时不被清理，错题不受影响；独立任务按自身保留期清理', async () => {
+        const item = await database.errorItem.create({ data: { userId: 'user-1', subjectId: 'math', questionText: '很早入库的题', originalImageUrl: '' } });
+        const old = new Date(Date.now() - 10 * DAY);
+        await database.importBatch.create({ data: { id: 'batch-long-draft', userId: 'user-1', source: 'text', splitter: 'local', status: 'started', mode: 'review', startedAt: old, createdAt: old } });
+        await database.importTask.createMany({ data: [
+            { id: 'old-saved-in-batch', userId: 'user-1', mode: 'review', status: 'saved', imageData: '', inputText: 'a', errorItemId: item.id, batchId: 'batch-long-draft', batchItemKey: 'qa', finishedAt: old, createdAt: old },
+            { id: 'pending-in-batch', userId: 'user-1', mode: 'review', status: 'review', imageData: '', inputText: 'b', result: null, batchId: 'batch-long-draft', batchItemKey: 'qb', createdAt: old },
+            { id: 'old-standalone', userId: 'user-1', mode: 'auto', status: 'saved', imageData: '', finishedAt: old, createdAt: old },
+        ] });
+        const list = await (await LIST()).json();
+        expect(list.batches.find((batch: { id: string }) => batch.id === 'batch-long-draft')).toMatchObject({ counts: { total: 2, saved: 1, review: 1 } });
+        expect(await database.importTask.count({ where: { id: 'old-saved-in-batch' } })).toBe(1);
+        expect(await database.importTask.count({ where: { id: 'old-standalone' } })).toBe(0);
+        expect(await database.errorItem.count({ where: { id: item.id } })).toBe(1);
+
+        // 全部入库且超过保留期后，批次连同其任务一起清理，错题保留
+        await database.importTask.update({ where: { id: 'pending-in-batch' }, data: { status: 'saved', finishedAt: old } });
+        await LIST();
+        expect(await database.importBatch.count({ where: { id: 'batch-long-draft' } })).toBe(0);
+        expect(await database.importTask.count({ where: { batchId: 'batch-long-draft' } })).toBe(0);
+        expect(await database.errorItem.count({ where: { id: item.id } })).toBe(1);
+    });
+
+    it('100 个较新的已完成批次不会挤掉更早的草稿，已完成的只列最近 10 个', async () => {
+        const base = Date.now() - DAY;
+        await database.importBatch.create({ data: { id: 'very-old-draft', userId: 'user-1', source: 'text', splitter: 'local', status: 'draft', createdAt: new Date(base - 30 * DAY) } });
+        await database.importBatch.createMany({ data: Array.from({ length: 100 }, (_, index) => ({
+            id: `done-batch-${String(index).padStart(3, '0')}`, userId: 'user-1', source: 'text', splitter: 'local', status: 'started',
+            startedAt: new Date(base + index * 1000), createdAt: new Date(base + index * 1000),
+        })) });
+        const list = await (await LIST()).json();
+        expect(list.batches.map((batch: { id: string }) => batch.id)).toContain('very-old-draft');
+        expect(list.batches.filter((batch: { phase: string }) => batch.phase === 'done')).toHaveLength(10);
+        expect(list.batches[0].id).toBe('done-batch-099');
+    });
+
+    it('状态查询、列表与草稿保存不从数据库读出整页图片，只有明确取图时读取', async () => {
+        const bigImage = `data:image/jpeg;base64,${'A'.repeat(2 * 1024 * 1024)}`;
+        const draft = { items: [{ key: 'qa', label: '1', text: '题', material: null, section: null, selected: true, regions: [{ x: 0, y: 0, width: 1, height: 0.5 }], hasFigure: false, flags: [] }], ignored: [], warnings: [] };
+        await database.importBatch.create({ data: { id: 'batch-big-image', userId: 'user-1', source: 'image', splitter: 'ai', status: 'draft', imageData: bigImage, draft: JSON.stringify(draft) } });
+        const selectsImage = () => queries.some((query) => /[`"]ImportBatch[`"]\.[`"]imageData[`"]/.test(query) && /^SELECT/i.test(query));
+
+        queries.length = 0;
+        const detail = await GET_BATCH(new Request('http://localhost/api/import-batches/batch-big-image'), params('batch-big-image'));
+        const detailText = await detail.text();
+        const listText = await (await LIST()).text();
+        const patched = await PATCH(json({ version: 1, draft }, 'PATCH'), params('batch-big-image'));
+        expect(patched.status).toBe(200);
+        const patchText = await patched.text();
+        expect(selectsImage()).toBe(false);
+        for (const text of [detailText, listText, patchText]) expect(text.length).toBeLessThan(50_000);
+
+        queries.length = 0;
+        const { batch } = await getBatch('batch-big-image', true);
+        expect(batch.imageData).toBe(bigImage);
+        expect(selectsImage()).toBe(true);
+    });
+});
+
 describe('批次归属与列表', () => {
     it('其他用户看不到、改不了、开始不了、丢弃不了他人的批次', async () => {
         const { batch } = await create({ source: 'text', text: '1．计算 1 + 1。\n2．计算 2 + 2。' });

src/lib/import-batches.ts

@@ -10,7 +10,7 @@
  */
 import { randomUUID } from "node:crypto";
 import { NextResponse } from "next/server";
-import type { ImportBatch, Prisma, User } from "@prisma/client";
+import type { Prisma, User } from "@prisma/client";
 import { z } from "zod";
 import { consumeAiQuota } from "@/lib/ai-quota";
 import { MAX_SPLIT_LINES } from "@/lib/ai/question-split";
@@ -87,7 +87,18 @@ const startSchema = z.object({
     })).max(60).optional(),
 });
 
-type BatchWithTasks = ImportBatch & { tasks: Array<Prisma.ImportTaskGetPayload<{ select: typeof summarySelect }>> };
+/**
+ * 批次读取默认不含整页图片（可能有几 MB）：状态轮询、列表与草稿保存都不从数据库读出原图，
+ * 只有预览页明确取图（?include=image）或后台分题时才读取
+ */
+const batchSelect = {
+    id: true, userId: true, clientRequestId: true, source: true, splitter: true, status: true, mode: true, language: true,
+    subjectId: true, targetSubjectId: true, paperLevel: true, sourceText: true, imageInfo: true, draft: true, version: true,
+    error: true, attempts: true, runnerId: true, heartbeatAt: true, readAt: true, startedAt: true, finishedAt: true,
+    createdAt: true, updatedAt: true,
+    tasks: { select: summarySelect },
+} satisfies Prisma.ImportBatchSelect;
+type BatchWithTasks = Prisma.ImportBatchGetPayload<{ select: typeof batchSelect }> & { imageData?: string };
 
 function parseDraft(raw: string | null): BatchDraft | null {
     if (!raw) return null;
@@ -154,7 +165,6 @@ function toDetail(batch: BatchWithTasks, options: { image?: boolean } = {}): Imp
     };
 }
 
-const batchInclude = { tasks: { select: summarySelect } } satisfies Prisma.ImportBatchInclude;
 
 /** 分题中但执行它的进程已不在：标记失败，可重试 */
 async function reconcileInterrupted(userId: string, batchId?: string): Promise<void> {
@@ -183,10 +193,7 @@ async function findOwnBatch(user: Pick<User, 'id'>, id: string, image = false):
     await reconcileInterrupted(user.id, id);
     // 批次内正在解析或保存的题若因服务重启中断，同样标记为失败，批次页不会一直显示进行中
     await reconcileInterruptedTasks(user.id);
-    const batch = await prisma.importBatch.findFirst({ where: { id, userId: user.id }, include: batchInclude });
-    if (!batch) return null;
-    if (!image) batch.imageData = '';
-    return batch;
+    return prisma.importBatch.findFirst({ where: { id, userId: user.id }, select: image ? { ...batchSelect, imageData: true } : batchSelect });
 }
 
 async function ownsNotebook(userId: string, subjectId: string | null | undefined): Promise<boolean> {
@@ -274,7 +281,7 @@ export async function createImportBatch(user: User, raw: unknown): Promise<Creat
 
     const existing = await prisma.importBatch.findUnique({
         where: { userId_clientRequestId: { userId: user.id, clientRequestId: input.clientRequestId } },
-        include: batchInclude,
+        select: batchSelect,
     });
     if (existing) return { batch: toDetail(existing), created: false };
     if (!await ownsNotebook(user.id, input.subjectId) || !await ownsNotebook(user.id, input.targetSubjectId)) {
@@ -315,14 +322,14 @@ export async function createImportBatch(user: User, raw: unknown): Promise<Creat
                 readAt: draft ? new Date() : null,
                 finishedAt: draft ? new Date() : null,
             },
-            include: batchInclude,
+            select: batchSelect,
         });
     } catch (error) {
         release();
         if ((error as { code?: string }).code === 'P2002') {
             const winner = await prisma.importBatch.findUnique({
                 where: { userId_clientRequestId: { userId: user.id, clientRequestId: input.clientRequestId } },
-                include: batchInclude,
+                select: batchSelect,
             });
             if (winner) return { batch: toDetail(winner), created: false };
         }
@@ -340,7 +347,6 @@ export async function createImportBatch(user: User, raw: unknown): Promise<Creat
         scheduleWork(id, release, () => runSplit(id));
     }
     logger.info({ batchId: id, source: input.source, splitter, questions: draft?.items.length ?? null }, 'Import batch created');
-    batch.imageData = '';
     return { batch: toDetail(batch), created: true };
 }
 
@@ -548,16 +554,24 @@ export async function markImportBatchRead(user: Pick<User, 'id'>, id: string): P
 export async function listImportBatches(user: Pick<User, 'id'>): Promise<ImportBatchSummary[]> {
     await reconcileInterrupted(user.id);
     await pruneDone(user.id);
-    const batches = await prisma.importBatch.findMany({
-        where: { userId: user.id },
-        include: batchInclude,
-        orderBy: { createdAt: 'desc' },
-        take: 100,
-    });
-    let done = 0;
-    return batches
-        .map((batch) => toBatchSummary(batch).summary)
-        .filter((summary) => summary.phase !== 'done' || done++ < MAX_LISTED_DONE);
+    // 未完成的批次（草稿、分题中/失败、仍有题未入库）全部返回，不会被较新的已完成批次挤出列表；
+    // 全部入库的批次只返回最近若干个
+    const [unfinished, done] = await Promise.all([
+        prisma.importBatch.findMany({
+            where: { userId: user.id, OR: [{ status: { not: 'started' } }, { tasks: { some: { status: { not: 'saved' } } } }] },
+            select: batchSelect,
+            orderBy: { createdAt: 'desc' },
+        }),
+        prisma.importBatch.findMany({
+            where: { userId: user.id, status: 'started', tasks: { every: { status: 'saved' } } },
+            select: batchSelect,
+            orderBy: { createdAt: 'desc' },
+            take: MAX_LISTED_DONE,
+        }),
+    ]);
+    return [...unfinished, ...done]
+        .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime())
+        .map((batch) => toBatchSummary(batch).summary);
 }
 
 /** 识别任务中心：单独上传的任务与多题批次，执行中数与未读数都包含批次 */

src/lib/import-tasks.ts

@@ -199,10 +199,10 @@ export async function reconcileInterrupted(userId: string, taskId?: string): Pro
     logger.info({ userId, count: interrupted.length }, 'Marked interrupted import tasks as failed');
 }
 
-/** 删除超过保留期的已保存任务 */
+/** 删除超过保留期的已保存独立任务；批次中的任务随批次一起保留或清理，不单独删除 */
 async function pruneSaved(userId: string): Promise<void> {
     const cutoff = new Date(Date.now() - SAVED_IMPORT_TASK_RETENTION_DAYS * 24 * 60 * 60 * 1000);
-    await prisma.importTask.deleteMany({ where: { userId, status: 'saved', finishedAt: { lt: cutoff } } });
+    await prisma.importTask.deleteMany({ where: { userId, batchId: null, status: 'saved', finishedAt: { lt: cutoff } } });
 }
 
 async function findOwnTask(user: Pick<User, 'id'>, id: string): Promise<TaskWithItem | null> {