feat(v2.2): 完成高频读取热路径

apps/server/src/modules/v22-query/v22-query.controller.spec.ts

@@ -0,0 +1,45 @@
+import { V22QueryController } from './v22-query.controller';
+
+describe('V22QueryController', () => {
+  it('forwards V2.2 hot-path requests to the query service', async () => {
+    const service = {
+      getVersionDetailData: jest.fn().mockResolvedValue({ version: { id: 'version-1' } }),
+      listRequirements: jest.fn().mockResolvedValue({ items: [], nextCursor: undefined }),
+      getWorkspaceData: jest.fn().mockResolvedValue({ devTasks: [] }),
+      getXiaobaoWarnings: jest.fn().mockResolvedValue([]),
+    };
+    const controller = new V22QueryController(service as any);
+
+    await controller.getVersionDetailData('version-1');
+    await controller.listRequirements(
+      'product-1',
+      'project-1',
+      undefined,
+      'adopted',
+      'P1',
+      'feature',
+      'login',
+      'created_at_asc',
+      'req-2',
+      '50',
+    );
+    await controller.getWorkspaceData('member-1');
+    await controller.getXiaobaoWarnings('member-1', 'false');
+
+    expect(service.getVersionDetailData).toHaveBeenCalledWith('version-1');
+    expect(service.listRequirements).toHaveBeenCalledWith({
+      productId: 'product-1',
+      projectId: 'project-1',
+      versionId: undefined,
+      status: 'adopted',
+      priority: 'P1',
+      type: 'feature',
+      q: 'login',
+      sort: 'created_at_asc',
+      cursor: 'req-2',
+      limit: '50',
+    });
+    expect(service.getWorkspaceData).toHaveBeenCalledWith('member-1');
+    expect(service.getXiaobaoWarnings).toHaveBeenCalledWith({ userId: 'member-1', manager: 'false' });
+  });
+});

apps/server/src/modules/v22-query/v22-query.controller.ts

@@ -0,0 +1,52 @@
+import { Controller, Get, Param, Query } from '@nestjs/common';
+import { V22QueryService } from './v22-query.service';
+
+@Controller('v2.2')
+export class V22QueryController {
+  constructor(private readonly v22QueryService: V22QueryService) {}
+
+  @Get('versions/:versionId/detail-data')
+  getVersionDetailData(@Param('versionId') versionId: string) {
+    return this.v22QueryService.getVersionDetailData(versionId);
+  }
+
+  @Get('requirements')
+  listRequirements(
+    @Query('productId') productId?: string,
+    @Query('projectId') projectId?: string,
+    @Query('versionId') versionId?: string,
+    @Query('status') status?: string,
+    @Query('priority') priority?: string,
+    @Query('type') type?: string,
+    @Query('q') q?: string,
+    @Query('sort') sort?: string,
+    @Query('cursor') cursor?: string,
+    @Query('limit') limit?: string,
+  ) {
+    return this.v22QueryService.listRequirements({
+      productId,
+      projectId,
+      versionId,
+      status,
+      priority,
+      type,
+      q,
+      sort,
+      cursor,
+      limit,
+    });
+  }
+
+  @Get('workspace')
+  getWorkspaceData(@Query('userId') userId: string) {
+    return this.v22QueryService.getWorkspaceData(userId);
+  }
+
+  @Get('xiaobao-warning')
+  getXiaobaoWarnings(
+    @Query('userId') userId?: string,
+    @Query('manager') manager?: string,
+  ) {
+    return this.v22QueryService.getXiaobaoWarnings({ userId, manager });
+  }
+}

apps/server/src/modules/v22-query/v22-query.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { V22QueryController } from './v22-query.controller';
+import { V22QueryService } from './v22-query.service';
+
+@Module({
+  controllers: [V22QueryController],
+  providers: [V22QueryService],
+})
+export class V22QueryModule {}

apps/server/src/modules/v22-query/v22-query.service.spec.ts

@@ -0,0 +1,157 @@
+import { BadRequestException, NotFoundException } from '@nestjs/common';
+import { V22QueryService } from './v22-query.service';
+
+function buildPrismaMock() {
+  return {
+    version: {
+      findUnique: jest.fn(),
+    },
+    requirement: {
+      findMany: jest.fn(),
+    },
+    versionPlan: {
+      findMany: jest.fn(),
+    },
+    devTask: {
+      findMany: jest.fn(),
+    },
+    testCase: {
+      findMany: jest.fn(),
+    },
+    bug: {
+      findMany: jest.fn(),
+    },
+    xiaobaoRiskSummary: {
+      findMany: jest.fn(),
+    },
+  };
+}
+
+describe('V22QueryService', () => {
+  it('loads version detail data through version-scoped relation queries', async () => {
+    const prisma = buildPrismaMock();
+    prisma.version.findUnique.mockResolvedValue({ id: 'version-1', productId: 'product-1', projectId: 'project-1' });
+    prisma.requirement.findMany.mockResolvedValue([{ id: 'req-1' }]);
+    prisma.versionPlan.findMany.mockResolvedValue([{ id: 'plan-1' }]);
+    prisma.devTask.findMany.mockResolvedValue([{ id: 'dev-1' }]);
+    prisma.testCase.findMany.mockResolvedValue([{ id: 'tc-1' }]);
+    prisma.bug.findMany.mockResolvedValue([{ id: 'bug-1' }]);
+    const service = new V22QueryService(prisma as any);
+
+    const result = await service.getVersionDetailData('version-1');
+
+    expect(result.requirements).toEqual([{ id: 'req-1' }]);
+    expect(result.devTasks).toEqual([{ id: 'dev-1' }]);
+    expect(prisma.requirement.findMany).toHaveBeenCalledWith({
+      where: { versionId: 'version-1' },
+      orderBy: { createdAt: 'desc' },
+    });
+    expect(prisma.devTask.findMany).toHaveBeenCalledWith({
+      where: { versionId: 'version-1' },
+      orderBy: [{ status: 'asc' }, { updatedAt: 'desc' }],
+    });
+  });
+
+  it('rejects missing productId for requirement pool queries to avoid full-table scans', async () => {
+    const service = new V22QueryService(buildPrismaMock() as any);
+
+    await expect(service.listRequirements({})).rejects.toBeInstanceOf(BadRequestException);
+  });
+
+  it('paginates requirement pool queries by product partition key and composite cursor', async () => {
+    const prisma = buildPrismaMock();
+    prisma.requirement.findMany.mockResolvedValue([{ id: 'req-2' }, { id: 'req-1' }]);
+    const service = new V22QueryService(prisma as any);
+
+    const result = await service.listRequirements({
+      productId: 'product-1',
+      projectId: 'project-1',
+      status: 'adopted',
+      priority: 'P1',
+      type: 'feature',
+      q: 'login',
+      sort: 'created_at_asc',
+      cursor: 'req-3',
+      limit: '1',
+    });
+
+    expect(result).toEqual({ items: [{ id: 'req-2' }], nextCursor: 'req-1' });
+    expect(prisma.requirement.findMany).toHaveBeenCalledWith({
+      where: {
+        productId: 'product-1',
+        projectId: 'project-1',
+        status: 'adopted',
+        priority: 1,
+        type: 'feature',
+        OR: [
+          { code: { contains: 'login', mode: 'insensitive' } },
+          { title: { contains: 'login', mode: 'insensitive' } },
+        ],
+      },
+      orderBy: { createdAt: 'asc' },
+      take: 2,
+      cursor: { id_productId: { id: 'req-3', productId: 'product-1' } },
+      skip: 1,
+    });
+  });
+
+  it('aggregates workspace rows by current user without scanning unrelated assignees', async () => {
+    const prisma = buildPrismaMock();
+    prisma.versionPlan.findMany.mockResolvedValue([{ id: 'plan-1' }]);
+    prisma.devTask.findMany.mockResolvedValue([{ id: 'dev-1' }]);
+    prisma.testCase.findMany.mockResolvedValue([{ id: 'tc-1' }]);
+    prisma.bug.findMany.mockResolvedValue([{ id: 'bug-1' }]);
+    const service = new V22QueryService(prisma as any);
+
+    const result = await service.getWorkspaceData('member-1');
+
+    expect(result).toEqual({
+      versionPlans: [{ id: 'plan-1' }],
+      devTasks: [{ id: 'dev-1' }],
+      testCases: [{ id: 'tc-1' }],
+      bugs: [{ id: 'bug-1' }],
+    });
+    expect(prisma.devTask.findMany).toHaveBeenCalledWith({
+      where: { assigneeId: 'member-1', status: { not: 'submitted' } },
+      orderBy: [{ priority: 'asc' }, { updatedAt: 'desc' }],
+    });
+    expect(prisma.bug.findMany).toHaveBeenCalledWith({
+      where: { assigneeId: 'member-1', status: { in: ['open', 'fixing', 'fixed', 'verifying'] } },
+      orderBy: [{ priority: 'asc' }, { updatedAt: 'desc' }],
+    });
+  });
+
+  it('loads Xiaobao warning summaries either globally for managers or by user-owned version ids', async () => {
+    const prisma = buildPrismaMock();
+    prisma.versionPlan.findMany.mockResolvedValue([{ versionId: 'version-1' }]);
+    prisma.devTask.findMany.mockResolvedValue([{ versionId: 'version-2' }]);
+    prisma.testCase.findMany.mockResolvedValue([{ versionId: 'version-2' }]);
+    prisma.bug.findMany.mockResolvedValue([{ versionId: 'version-3' }]);
+    prisma.xiaobaoRiskSummary.findMany.mockResolvedValue([{ versionId: 'version-2', riskScore: 70 }]);
+    const service = new V22QueryService(prisma as any);
+
+    const userResult = await service.getXiaobaoWarnings({ userId: 'member-1' });
+    await service.getXiaobaoWarnings({ manager: 'true' });
+
+    expect(userResult).toEqual([{ versionId: 'version-2', riskScore: 70 }]);
+    expect(prisma.xiaobaoRiskSummary.findMany).toHaveBeenNthCalledWith(1, {
+      where: {
+        versionId: { in: ['version-1', 'version-2', 'version-3'] },
+        riskLevel: { not: 'on_track' },
+      },
+      orderBy: [{ riskScore: 'desc' }, { updatedAt: 'desc' }],
+    });
+    expect(prisma.xiaobaoRiskSummary.findMany).toHaveBeenNthCalledWith(2, {
+      where: { riskLevel: { not: 'on_track' } },
+      orderBy: [{ riskScore: 'desc' }, { updatedAt: 'desc' }],
+    });
+  });
+
+  it('throws when a version detail query targets a missing version', async () => {
+    const prisma = buildPrismaMock();
+    prisma.version.findUnique.mockResolvedValue(null);
+    const service = new V22QueryService(prisma as any);
+
+    await expect(service.getVersionDetailData('missing-version')).rejects.toBeInstanceOf(NotFoundException);
+  });
+});

apps/server/src/modules/v22-query/v22-query.service.ts

@@ -0,0 +1,185 @@
+import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
+import { PrismaService } from '../../prisma/prisma.service';
+
+interface RequirementQuery {
+  productId?: string;
+  projectId?: string;
+  versionId?: string;
+  status?: string;
+  priority?: string;
+  type?: string;
+  q?: string;
+  sort?: string;
+  cursor?: string;
+  limit?: string;
+}
+
+interface XiaobaoWarningQuery {
+  userId?: string;
+  manager?: string;
+}
+
+@Injectable()
+export class V22QueryService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async getVersionDetailData(versionId: string) {
+    const version = await this.prisma.version.findUnique({ where: { id: versionId } });
+    if (!version) throw new NotFoundException('Version not found');
+
+    const [requirements, versionPlans, devTasks, testCases, bugs] = await Promise.all([
+      this.prisma.requirement.findMany({
+        where: { versionId },
+        orderBy: { createdAt: 'desc' },
+      }),
+      this.prisma.versionPlan.findMany({
+        where: { versionId },
+        orderBy: [{ type: 'asc' }, { createdAt: 'desc' }],
+      }),
+      this.prisma.devTask.findMany({
+        where: { versionId },
+        orderBy: [{ status: 'asc' }, { updatedAt: 'desc' }],
+      }),
+      this.prisma.testCase.findMany({
+        where: { versionId },
+        orderBy: [{ roundNo: 'desc' }, { status: 'asc' }, { updatedAt: 'desc' }],
+      }),
+      this.prisma.bug.findMany({
+        where: { versionId },
+        orderBy: [{ status: 'asc' }, { priority: 'asc' }, { updatedAt: 'desc' }],
+      }),
+    ]);
+
+    return { version, requirements, versionPlans, devTasks, testCases, bugs };
+  }
+
+  async listRequirements(query: RequirementQuery) {
+    const productId = query.productId?.trim();
+    if (!productId) {
+      throw new BadRequestException('productId is required for requirement pool queries');
+    }
+
+    const limit = parseLimit(query.limit);
+    const priority = parsePriority(query.priority);
+    const search = query.q?.trim();
+    const sortDirection = query.sort === 'created_at_asc' ? 'asc' : 'desc';
+    const rows = await this.prisma.requirement.findMany({
+      where: {
+        productId,
+        ...(query.projectId?.trim() ? { projectId: query.projectId.trim() } : {}),
+        ...(query.versionId?.trim() ? { versionId: query.versionId.trim() } : {}),
+        ...(query.status?.trim() ? { status: query.status.trim() } : {}),
+        ...(priority !== undefined ? { priority } : {}),
+        ...(query.type?.trim() ? { type: query.type.trim() } : {}),
+        ...(search
+          ? {
+            OR: [
+              { code: { contains: search, mode: 'insensitive' as const } },
+              { title: { contains: search, mode: 'insensitive' as const } },
+            ],
+          }
+          : {}),
+      },
+      orderBy: { createdAt: sortDirection },
+      take: limit + 1,
+      ...(query.cursor
+        ? {
+          cursor: { id_productId: { id: query.cursor, productId } },
+          skip: 1,
+        }
+        : {}),
+    });
+
+    const hasNext = rows.length > limit;
+    return {
+      items: hasNext ? rows.slice(0, limit) : rows,
+      nextCursor: hasNext ? rows[limit]?.id : undefined,
+    };
+  }
+
+  async getWorkspaceData(userId: string) {
+    const normalizedUserId = userId.trim();
+    if (!normalizedUserId) throw new BadRequestException('userId is required');
+
+    const [versionPlans, devTasks, testCases, bugs] = await Promise.all([
+      this.prisma.versionPlan.findMany({
+        where: { ownerId: normalizedUserId, status: { not: 'completed' } },
+        orderBy: [{ expectedEndAt: 'asc' }, { updatedAt: 'desc' }],
+      }),
+      this.prisma.devTask.findMany({
+        where: { assigneeId: normalizedUserId, status: { not: 'submitted' } },
+        orderBy: [{ priority: 'asc' }, { updatedAt: 'desc' }],
+      }),
+      this.prisma.testCase.findMany({
+        where: { assigneeId: normalizedUserId, status: { notIn: ['passed', 'failed', 'blocked'] } },
+        orderBy: [{ priority: 'asc' }, { updatedAt: 'desc' }],
+      }),
+      this.prisma.bug.findMany({
+        where: { assigneeId: normalizedUserId, status: { in: ['open', 'fixing', 'fixed', 'verifying'] } },
+        orderBy: [{ priority: 'asc' }, { updatedAt: 'desc' }],
+      }),
+    ]);
+
+    return { versionPlans, devTasks, testCases, bugs };
+  }
+
+  async getXiaobaoWarnings(query: XiaobaoWarningQuery) {
+    if (query.manager === 'true') {
+      return this.prisma.xiaobaoRiskSummary.findMany({
+        where: { riskLevel: { not: 'on_track' } },
+        orderBy: [{ riskScore: 'desc' }, { updatedAt: 'desc' }],
+      });
+    }
+
+    const userId = query.userId?.trim();
+    if (!userId) throw new BadRequestException('userId is required');
+    const versionIds = await this.getUserOwnedVersionIds(userId);
+    if (versionIds.length === 0) return [];
+
+    return this.prisma.xiaobaoRiskSummary.findMany({
+      where: {
+        versionId: { in: versionIds },
+        riskLevel: { not: 'on_track' },
+      },
+      orderBy: [{ riskScore: 'desc' }, { updatedAt: 'desc' }],
+    });
+  }
+
+  private async getUserOwnedVersionIds(userId: string): Promise<string[]> {
+    const [plans, devTasks, testCases, bugs] = await Promise.all([
+      this.prisma.versionPlan.findMany({
+        where: { ownerId: userId, status: { not: 'completed' } },
+        select: { versionId: true },
+      }),
+      this.prisma.devTask.findMany({
+        where: { assigneeId: userId, status: { not: 'submitted' } },
+        select: { versionId: true },
+      }),
+      this.prisma.testCase.findMany({
+        where: { assigneeId: userId, status: { notIn: ['passed', 'failed', 'blocked'] } },
+        select: { versionId: true },
+      }),
+      this.prisma.bug.findMany({
+        where: { assigneeId: userId, status: { in: ['open', 'fixing', 'fixed', 'verifying'] } },
+        select: { versionId: true },
+      }),
+    ]);
+    return Array.from(new Set([...plans, ...devTasks, ...testCases, ...bugs].map((item) => item.versionId)));
+  }
+}
+
+function parseLimit(raw?: string): number {
+  const parsed = raw ? Number(raw) : 50;
+  if (!Number.isFinite(parsed)) return 50;
+  return Math.max(1, Math.min(200, Math.floor(parsed)));
+}
+
+function parsePriority(raw?: string): number | undefined {
+  const normalized = raw?.trim().toUpperCase();
+  if (!normalized) return undefined;
+  const prefixed = /^P([0-4])$/.exec(normalized);
+  if (prefixed) return Number(prefixed[1]);
+  const parsed = Number(normalized);
+  if (!Number.isFinite(parsed)) return undefined;
+  return Math.max(0, Math.min(4, Math.floor(parsed)));
+}