perf: optimize portfolio queries and workflows

apps/api/src/portfolio.ts

@@ -7,14 +7,23 @@ import {
   Body,
   Req,
   Param,
+  Query,
   NotFoundException,
   ConflictException,
   BadRequestException,
 } from '@nestjs/common';
 import { Database } from './database';
 import { UserRequest } from './auth';
-import { positionInput, positionMeta, revisionInput, today, toBusinessDate } from './validation';
-import { history, overview } from './calculation';
+import {
+  positionInput,
+  positionMeta,
+  revisionInput,
+  today,
+  toBusinessDate,
+  pairedReasons,
+} from './validation';
+import { totals, trend } from './calculation';
+import { currentPositions, currentRates, historyPage, trendData, trendInput } from './queries';
 import { z } from 'zod';
 import { Prisma } from '@prisma/client';
 import { IconsService } from './icons';
@@ -27,35 +36,70 @@ export class PortfolioController {
     private icons: IconsService,
   ) {}
   private async own(userId: string, id: string, revealed = false) {
-    const p = await this.db.position.findFirst({
-      where: { id, userId, ...(revealed ? {} : { hidden: false }) },
-      include: {
-        revisions: { orderBy: [{ effectiveDate: 'asc' }, { sequence: 'asc' }] },
-        outgoing: true,
-      },
-    });
+    const [p] = await this.db.$transaction((tx) => currentPositions(tx, userId, revealed, id));
     if (!p) throw new NotFoundException('项目不存在');
     return p;
   }
-  @Get('positions') async list(@Req() r: UserRequest) {
-    const rows = await this.db.position.findMany({
-      where: { userId: r.userId, ...(r.revealed ? {} : { hidden: false }) },
-      include: {
-        revisions: { orderBy: [{ effectiveDate: 'asc' }, { sequence: 'asc' }] },
-        outgoing: true,
-      },
-      orderBy: { createdAt: 'desc' },
+  @Get('positions') async list(@Req() r: UserRequest, @Query('kind') inputKind?: string) {
+    const kind = z.enum(['account', 'asset', 'debt']).optional().parse(inputKind);
+    return this.db.$transaction(async (tx) => {
+      const rows = await currentPositions(tx, r.userId, r.revealed, undefined, kind);
+      const user = await tx.user.findUniqueOrThrow({
+        where: { id: r.userId },
+        select: { baseCurrency: true },
+      });
+      const rates = await currentRates(
+        tx,
+        r.userId,
+        rows.map((p) => p.currency),
+        user.baseCurrency,
+        today(),
+      );
+      const amounts = new Map(
+        totals(rows, rates, user.baseCurrency, today()).items.map((p) => [p.id, p]),
+      );
+      return rows.map(({ revisions, userId, ...p }) => ({
+        ...p,
+        amount: revisions[0]?.amount.toString() || '0',
+        converted: amounts.get(p.id)!.converted,
+        rateDate: amounts.get(p.id)!.rateDate,
+      }));
     });
-    return rows.map((p) => ({
-      ...p,
-      userId: undefined,
-      amount: p.revisions.at(-1)?.amount.toString() || '0',
-      history: history(p),
-    }));
   }
   @Get('positions/:id') async detail(@Req() r: UserRequest, @Param('id') id: string) {
-    const p = await this.own(r.userId, id, r.revealed);
-    return { ...p, userId: undefined, history: history(p) };
+    const { revisions, userId, ...p } = await this.own(r.userId, id, r.revealed);
+    return { ...p, amount: revisions[0]?.amount.toString() || '0' };
+  }
+  @Get('history') async history(@Req() r: UserRequest, @Query() query: unknown) {
+    return this.db.$transaction((tx) => historyPage(tx, r.userId, r.revealed, query));
+  }
+  @Get('positions/:id/history') async positionHistory(
+    @Req() r: UserRequest,
+    @Param('id') id: string,
+    @Query() query: Record<string, string>,
+  ) {
+    return this.db.$transaction(async (tx) => {
+      const p = await tx.position.findFirst({
+        where: { id, userId: r.userId, ...(r.revealed ? {} : { hidden: false }) },
+      });
+      if (!p) throw new NotFoundException('项目不存在');
+      return historyPage(tx, r.userId, r.revealed, { ...query, positionId: id });
+    });
+  }
+  @Get('trend') async trend(@Req() r: UserRequest, @Query() query: unknown) {
+    const q = trendInput(query);
+    return this.db.$transaction(
+      async (tx) => {
+        const data = await trendData(tx, r.userId, r.revealed, q.from, q.to);
+        return {
+          ...q,
+          baseCurrency: data.base,
+          revealed: r.revealed,
+          items: trend(data.positions, data.rates, data.base, q.from, q.to, q.grain),
+        };
+      },
+      { timeout: 30000 },
+    );
   }
   @Post('positions') async create(@Req() r: UserRequest, @Body() b: unknown) {
     const v = positionInput.parse(b),
@@ -102,41 +146,41 @@ export class PortfolioController {
     @Body() b: unknown,
   ) {
     const v = revisionInput.parse(b);
-    if (v.reason.startsWith('transfer_')) throw new BadRequestException('请使用账户转账接口');
-    return this.db.$transaction(
-      async (tx) => {
-        const p = await tx.position.findFirst({
-          where: { id, userId: r.userId, ...(r.revealed ? {} : { hidden: false }) },
-        });
-        if (!p) throw new NotFoundException('项目不存在');
-        if (p.archived) throw new ConflictException('请先恢复归档项目');
-        const lastTransfer = await tx.revision.findFirst({
-          where: { positionId: p.id, reason: { in: ['transfer_out', 'transfer_in'] } },
+    if (pairedReasons.includes(v.reason)) throw new BadRequestException('请使用账户转账接口');
+    return this.db.serial(async (tx) => {
+      await tx.$queryRaw(
+        Prisma.sql`SELECT id FROM Position WHERE id = ${id} AND userId = ${r.userId} FOR UPDATE`,
+      );
+      const p = await tx.position.findFirst({
+        where: { id, userId: r.userId, ...(r.revealed ? {} : { hidden: false }) },
+      });
+      if (!p) throw new NotFoundException('项目不存在');
+      if (p.archived) throw new ConflictException('请先恢复归档项目');
+      const lastTransfer = await tx.revision.findFirst({
+        where: { positionId: p.id, reason: { in: pairedReasons } },
+        orderBy: [{ effectiveDate: 'desc' }, { sequence: 'desc' }],
+      });
+      if (lastTransfer && toBusinessDate(v.date) < lastTransfer.effectiveDate)
+        throw new ConflictException('余额调整时间不能早于已有转账；请使用当前时间调整');
+      if (v.reason === 'repayment') {
+        if (p.side !== 'liability') throw new BadRequestException('还款记录只能用于负债');
+        const prior = await tx.revision.findFirst({
+          where: { positionId: p.id, effectiveDate: { lte: toBusinessDate(v.date) } },
           orderBy: [{ effectiveDate: 'desc' }, { sequence: 'desc' }],
         });
-        if (lastTransfer && toBusinessDate(v.date) < lastTransfer.effectiveDate)
-          throw new ConflictException('余额调整时间不能早于已有转账；请使用当前时间调整');
-        if (v.reason === 'repayment') {
-          if (p.side !== 'liability') throw new BadRequestException('还款记录只能用于负债');
-          const prior = await tx.revision.findFirst({
-            where: { positionId: p.id, effectiveDate: { lte: toBusinessDate(v.date) } },
-            orderBy: [{ effectiveDate: 'desc' }, { sequence: 'desc' }],
-          });
-          if (!prior || new Prisma.Decimal(v.amount).gt(prior.amount))
-            throw new BadRequestException('还款后的欠款不能高于该业务日期的原欠款');
-        }
-        return tx.revision.create({
-          data: {
-            positionId: p.id,
-            amount: v.amount,
-            effectiveDate: toBusinessDate(v.date),
-            notes: v.notes,
-            reason: v.reason,
-          },
-        });
-      },
-      { isolationLevel: Prisma.TransactionIsolationLevel.Serializable },
-    );
+        if (!prior || new Prisma.Decimal(v.amount).gt(prior.amount))
+          throw new BadRequestException('还款后的欠款不能高于该业务日期的原欠款');
+      }
+      return tx.revision.create({
+        data: {
+          positionId: p.id,
+          amount: v.amount,
+          effectiveDate: toBusinessDate(v.date),
+          notes: v.notes,
+          reason: v.reason,
+        },
+      });
+    });
   }
   @Put('positions/:id/revisions/:revisionId') async correct(
     @Req() r: UserRequest,
@@ -145,40 +189,45 @@ export class PortfolioController {
     @Body() b: unknown,
   ) {
     const v = revisionInput.parse(b);
-    return this.db.$transaction(
-      async (tx) => {
-        const p = await tx.position.findFirst({
-          where: { id, userId: r.userId, ...(r.revealed ? {} : { hidden: false }) },
-          include: { revisions: true },
-        });
-        if (!p) throw new NotFoundException('项目不存在');
-        if (p.archived) throw new ConflictException('请先恢复归档项目');
-        const original = p.revisions.find((h) => h.id === revisionId);
-        if (!original) throw new NotFoundException('历史记录不存在');
-        if (
-          p.revisions.some(
-            (h) =>
-              h.reason.startsWith('transfer_') &&
-              (+h.effectiveDate >= +original.effectiveDate ||
-                toBusinessDate(v.date) < h.effectiveDate),
-          )
-        )
-          throw new ConflictException(
-            '转账及其之前的历史不可单独更正；请新增余额调整，保留转账双方一致',
-          );
-        await tx.revision.update({
-          where: { id: revisionId },
-          data: {
-            amount: v.amount,
-            effectiveDate: toBusinessDate(v.date),
-            notes: v.notes,
-            reason: 'correction',
-          },
-        });
-        return { ok: true };
-      },
-      { isolationLevel: Prisma.TransactionIsolationLevel.Serializable },
-    );
+    return this.db.serial(async (tx) => {
+      await tx.$queryRaw(
+        Prisma.sql`SELECT id FROM Position WHERE id = ${id} AND userId = ${r.userId} FOR UPDATE`,
+      );
+      const p = await tx.position.findFirst({
+        where: { id, userId: r.userId, ...(r.revealed ? {} : { hidden: false }) },
+      });
+      if (!p) throw new NotFoundException('项目不存在');
+      if (p.archived) throw new ConflictException('请先恢复归档项目');
+      const original = await tx.revision.findFirst({ where: { id: revisionId, positionId: p.id } });
+      if (!original) throw new NotFoundException('历史记录不存在');
+      const transfer = await tx.revision.findFirst({
+        where: {
+          positionId: p.id,
+          reason: { in: pairedReasons },
+          OR: [
+            { effectiveDate: { gt: original.effectiveDate } },
+            { effectiveDate: original.effectiveDate, sequence: { gte: original.sequence } },
+            { effectiveDate: { gt: toBusinessDate(v.date) } },
+            { effectiveDate: toBusinessDate(v.date), sequence: { gte: original.sequence } },
+          ],
+        },
+        select: { id: true },
+      });
+      if (transfer)
+        throw new ConflictException(
+          '转账及其之前的历史不可单独更正；请新增余额调整，保留转账双方一致',
+        );
+      await tx.revision.update({
+        where: { id: revisionId },
+        data: {
+          amount: v.amount,
+          effectiveDate: toBusinessDate(v.date),
+          notes: v.notes,
+          reason: 'correction',
+        },
+      });
+      return { ok: true };
+    });
   }
 
   @Put('positions/:id/links') async link(
@@ -192,38 +241,42 @@ export class PortfolioController {
       .parse(b);
     if (new Set(targetIds).size !== targetIds.length || targetIds.includes(id))
       throw new BadRequestException('关联不能重复或指向自身');
-    return this.db.$transaction(
-      async (tx) => {
-        const source = await tx.position.findFirst({
-          where: { id, userId: r.userId, kind: 'debt', ...(r.revealed ? {} : { hidden: false }) },
-        });
-        if (!source) throw new NotFoundException('债务不存在');
-        const count = await tx.position.count({
-          where: { id: { in: targetIds }, userId: r.userId, kind: { in: ['account', 'asset'] } },
-        });
-        if (count !== targetIds.length) throw new BadRequestException('只能关联自己的账户或资产');
-        await tx.positionLink.deleteMany({ where: { sourceId: id } });
-        await tx.positionLink.createMany({
-          data: targetIds.map((targetId) => ({ sourceId: id, targetId })),
-        });
-        return { ok: true };
-      },
-      { isolationLevel: Prisma.TransactionIsolationLevel.Serializable },
-    );
+    return this.db.serial(async (tx) => {
+      const source = await tx.position.findFirst({
+        where: { id, userId: r.userId, kind: 'debt', ...(r.revealed ? {} : { hidden: false }) },
+      });
+      if (!source) throw new NotFoundException('债务不存在');
+      const count = await tx.position.count({
+        where: { id: { in: targetIds }, userId: r.userId, kind: { in: ['account', 'asset'] } },
+      });
+      if (count !== targetIds.length) throw new BadRequestException('只能关联自己的账户或资产');
+      await tx.positionLink.deleteMany({ where: { sourceId: id } });
+      await tx.positionLink.createMany({
+        data: targetIds.map((targetId) => ({ sourceId: id, targetId })),
+      });
+      return { ok: true };
+    });
   }
   @Get('overview') async overview(@Req() r: UserRequest) {
     void this.fx.daily(r.userId);
-    const [user, positions, rates] = await this.db.$transaction([
-      this.db.user.findUniqueOrThrow({
+    return this.db.$transaction(async (tx) => {
+      const user = await tx.user.findUniqueOrThrow({
         where: { id: r.userId },
         select: { baseCurrency: true },
-      }),
-      this.db.position.findMany({
-        where: { userId: r.userId, ...(r.revealed ? {} : { hidden: false }) },
-        include: { revisions: true },
-      }),
-      this.db.exchangeRate.findMany({ where: { userId: r.userId } }),
-    ]);
-    return { ...overview(positions, rates, user.baseCurrency, today()), revealed: r.revealed };
+      });
+      const positions = await currentPositions(tx, r.userId, r.revealed);
+      const rates = await currentRates(
+        tx,
+        r.userId,
+        positions.map((p) => p.currency),
+        user.baseCurrency,
+        today(),
+      );
+      return {
+        baseCurrency: user.baseCurrency,
+        ...totals(positions, rates, user.baseCurrency, today()),
+        revealed: r.revealed,
+      };
+    });
   }
 }