第 09 集：AI 辅助重构遗留代码

// 重构前：processOrder 方法做了 5 件事
async processOrder(data: any) {
  // 计算折扣（30 行）
  // 验证用户（20 行）
  // 创建数据库记录（10 行）
  // 发送通知（15 行）
  // 更新库存（10 行）
}

// 重构后：每件事是独立的私有方法
async processOrder(data: CreateOrderDto) {
  const discount = this.calculateDiscount(data.amount);
  const user = await this.validateUser(data.userId);
  const order = await this.createOrderRecord(data, discount);
  await this.sendNotification(user, order);
  await this.updateStock(data.items);
  return order;
}

// 重构前
if (data.amount > 10000) {
    discount = data.amount * 0.1
} else if (data.amount > 5000) {
    discount = data.amount * 0.05
}

// 重构后
const DISCOUNT_RULES = {
    HIGH_THRESHOLD: 10000,
    MID_THRESHOLD: 5000,
    HIGH_RATE: 0.1,
    MID_RATE: 0.05,
} as const

if (data.amount > DISCOUNT_RULES.HIGH_THRESHOLD) {
    discount = data.amount * DISCOUNT_RULES.HIGH_RATE
}

// 重构前：两个方法里都有相同的用户验证逻辑
async processOrder(data) {
  const user = await this.prisma.user.findUnique({ where: { id: data.userId } });
  if (!user) throw new NotFoundException('用户不存在');
  if (!user.isActive) throw new ForbiddenException('用户已被禁用');
  // ...
}

async cancelOrder(data) {
  const user = await this.prisma.user.findUnique({ where: { id: data.userId } });
  if (!user) throw new NotFoundException('用户不存在');
  if (!user.isActive) throw new ForbiddenException('用户已被禁用');
  // ...
}

// 重构后：提取为私有方法
private async validateUser(userId: number): Promise<User> {
  const user = await this.prisma.user.findUnique({ where: { id: userId } });
  if (!user) throw new NotFoundException('用户不存在');
  if (!user.isActive) throw new ForbiddenException('用户已被禁用');
  return user;
}

// 重构前
async create(data: any) {
  const result: any = await this.prisma.user.create({ data });
  return result;
}

// 重构后
async create(createUserDto: CreateUserDto): Promise<Omit<User, 'password'>> {
  const { password, ...rest } = createUserDto;
  const hashedPassword = await bcrypt.hash(password, 10);
  const user = await this.prisma.user.create({
    data: { ...rest, password: hashedPassword },
    select: { id: true, username: true, email: true, createdAt: true },
  });
  return user;
}

// 重构前
if (!user) {
    throw new Error('user not found') // 会变成 500，而不是 404
}

// 重构后
if (!user) {
    throw new NotFoundException('用户不存在') // 正确返回 404
}

// 重构前（直接修改入参，有副作用）
async processOrder(data: any) {
  data.discount = this.calculateDiscount(data.amount);  // 修改了 data
  data.finalAmount = data.amount - data.discount;        // 修改了 data
  data.status = 'PENDING';                               // 修改了 data
  return await this.prisma.order.create({ data });
}

// 重构后（用新对象，无副作用）
async processOrder(createOrderDto: CreateOrderDto) {
  const discount = this.calculateDiscount(createOrderDto.amount);
  const orderData = {
    ...createOrderDto,
    discount,
    finalAmount: createOrderDto.amount - discount,
    status: OrderStatus.PENDING,
  };
  return await this.prisma.order.create({ data: orderData });
}

1. 为现有代码（有坏味道的代码）写测试
2. 确认测试全绿（验证现有行为）
3. 开始重构
4. 每改一步，运行一次测试
5. 测试保持全绿，重构安全

import { Injectable } from '@nestjs/common'
import { PrismaService } from '../prisma/prisma.service'

// 这是演示用的遗留代码文件，包含多种典型坏味道

@Injectable()
export class OrderProcessorService {
    constructor(private p: PrismaService) {} // 坏味道1：单字母变量名

    // 坏味道2：函数过长，做了太多事情（超过 50 行）
    // 坏味道3：any 类型
    // 坏味道4：没有 JSDoc 注释
    async processOrder(data: any) {
        // 坏味道5：幻数
        if (data.amount > 10000) {
            data.discount = data.amount * 0.1
        } else if (data.amount > 5000) {
            data.discount = data.amount * 0.05
        } else if (data.amount > 1000) {
            data.discount = data.amount * 0.02
        } else {
            data.discount = 0
        }

        // 坏味道6：直接修改入参（副作用）
        data.finalAmount = data.amount - data.discount
        data.status = 'PENDING'
        data.orderNo = 'ORD' + Date.now()

        // 坏味道7：数据库操作和业务逻辑混在一起
        const user = await this.p.user.findUnique({
            where: { id: data.userId },
        })

        // 坏味道8：用 Error 而不是 NestJS 异常类
        if (!user) {
            throw new Error('user not found')
        }

        // 坏味道9：重复代码（cancelOrder 里也有这段）
        if (!user.isActive) {
            throw new Error('user is inactive')
        }

        const order = await this.p.order.create({ data })

        // 坏味道10：console.log 在生产代码里
        console.log('order created', order.id)

        return order
    }

    // 坏味道11：和 processOrder 高度重复的用户验证逻辑
    async cancelOrder(data: any) {
        const user = await this.p.user.findUnique({
            where: { id: data.userId },
        })
        if (!user) {
            throw new Error('user not found')
        }
        if (!user.isActive) {
            throw new Error('user is inactive')
        }

        const order = await this.p.order.findUnique({
            where: { id: data.orderId },
        })
        if (!order) {
            throw new Error('order not found')
        }

        // 坏味道12：幻字符串
        if (order.status !== 'PENDING') {
            throw new Error('only pending orders can be cancelled')
        }

        return await this.p.order.update({
            where: { id: data.orderId },
            data: { status: 'CANCELLED' },
        })
    }
}

mkdir -p src/legacy

@src/legacy/order-processor.service.ts

为 OrderProcessorService 生成单元测试文件 src/legacy/order-processor.service.spec.ts。

目的：在重构前先验证当前行为，作为重构的安全网。

覆盖场景：
- processOrder：正常流程（amount = 6000，用户存在且激活）
- processOrder：用户不存在时抛出 Error('user not found')
- processOrder：用户未激活时抛出 Error('user is inactive')
- cancelOrder：正常取消 PENDING 订单
- cancelOrder：订单不是 PENDING 状态时抛出 Error

注意：Mock 要覆盖 this.p（PrismaService），字段是 user 和 order

npm test -- order-processor.service.spec.ts --verbose

@src/legacy/order-processor.service.ts

分析这个文件里所有的代码坏味道，按以下格式输出：

### [编号]. [坏味道名称]
- 位置：第几行，哪个方法
- 问题描述：具体是什么问题
- 危害：这个问题会带来什么后果
- 重构方向：应该怎么改

按危害程度从高到低排序

根据上面的坏味道分析，帮我制定重构计划。

要求：
1. 从风险最低的改动开始（不改逻辑，只改形式的改动放最前面）
2. 每步改动范围要小，改完就运行测试
3. 用步骤编号列出，每步说明：改什么、为什么先改这个

第一步：提取常量（幻数 → 有名字的常量）
第二步：修复异常类型（Error → NestJS 异常类）
第三步：重命名变量（单字母 → 有意义的名字）
第四步：提取重复的用户验证逻辑（→ 私有方法）
第五步：拆分 processOrder 函数（→ 多个小方法）
第六步：修复 any 类型（→ 具体的 TypeScript 类型）
第七步：删除 console.log

执行重构第一步：提取 processOrder 方法里的所有幻数为命名常量。

在类定义上方创建常量对象：
const DISCOUNT_RULES = {
  HIGH_THRESHOLD: 10000,
  MID_THRESHOLD: 5000,
  LOW_THRESHOLD: 1000,
  HIGH_RATE: 0.1,
  MID_RATE: 0.05,
  LOW_RATE: 0.02,
} as const;

用这些常量替换方法里的幻数。不要改其他任何东西。

npm test -- order-processor.service.spec.ts --verbose

执行重构第二步：把所有的 throw new Error(...) 替换成 NestJS 异常类。

替换规则：
- 'user not found' → NotFoundException('用户不存在')
- 'user is inactive' → ForbiddenException('用户已被禁用')
- 'order not found' → NotFoundException('订单不存在')
- 'only pending orders can be cancelled' → BadRequestException('只有待处理的订单可以取消')

记得在文件顶部 import 这些异常类。不要改其他任何东西。

测试文件里的断言用的是 Error，但代码已经改成了 NestJS 异常类，
请同步更新测试文件里对应的断言

执行重构第三步：把构造函数里的 private p: PrismaService 改成 private prisma: PrismaService，
并把文件里所有 this.p. 替换为 this.prisma.。不要改其他任何东西。

执行重构第四步：把 processOrder 和 cancelOrder 里重复的用户验证逻辑提取成私有方法。

私有方法签名：
private async validateUser(userId: number): Promise<User>

方法逻辑：
1. 查找用户
2. 用户不存在抛 NotFoundException
3. 用户未激活抛 ForbiddenException
4. 返回用户对象

然后在 processOrder 和 cancelOrder 里调用这个方法，删除重复代码。

执行重构第五步：删除所有 console.log 语句。
如果需要日志，注入 NestJS Logger 并替换为 this.logger.log。
不要改其他任何东西。

git diff src/legacy/order-processor.service.ts

# 重构前行数
git show HEAD:src/legacy/order-processor.service.ts | wc -l

# 重构后行数
wc -l src/legacy/order-processor.service.ts

读取 @src/legacy/order.service.ts，告诉我：
1. 这个文件总共做了哪些事情（功能清单）
2. 主要的数据流是什么（数据从哪来，怎么处理，返回什么）
3. 有哪些外部依赖（数据库、第三方服务、全局变量等）
4. 有没有明显的副作用（发邮件、写文件、修改全局状态等）

继续分析 @src/legacy/order.service.ts，识别以下代码坏味道：

1. 过长函数（超过 30 行的函数）
2. 过大的类（承担了超过一个职责的 Service）
3. 重复代码（相似逻辑出现了多次）
4. 魔法数字/魔法字符串（硬编码的数字、状态值）
5. 深层嵌套（超过 3 层的 if/for 嵌套）
6. 注释掉的死代码
7. 不恰当的命名（变量名 a、b、temp 等）
8. 没有错误处理的异步操作

按照严重程度排序，优先列出影响最大的问题。

// ❌ 重构前：典型的遗留代码
export class OrderService {
    constructor(
        private db: any,
        private mailer: any
    ) {}

    async processOrder(data: any) {
        // 校验
        if (!data.userId) throw new Error('no user')
        if (!data.items || data.items.length === 0) throw new Error('no items')

        let total = 0
        for (let i = 0; i < data.items.length; i++) {
            const item = await this.db.query(
                `SELECT * FROM products WHERE id = ${data.items[i].productId}`
            )
            if (!item) throw new Error('product not found')
            if (item.stock < data.items[i].quantity) throw new Error('no stock')
            total += item.price * data.items[i].quantity
        }

        // 打折
        if (total > 1000) {
            total = total * 0.9
        } else if (total > 500) {
            total = total * 0.95
        }

        // 创建订单
        const orderId = Math.random().toString(36).substr(2, 9)
        await this.db.query(
            `INSERT INTO orders (id, user_id, total, status) VALUES ('${orderId}', '${data.userId}', ${total}, 1)`
        )

        for (let i = 0; i < data.items.length; i++) {
            await this.db.query(
                `INSERT INTO order_items (order_id, product_id, quantity) VALUES ('${orderId}', '${data.items[i].productId}', ${data.items[i].quantity})`
            )
            await this.db.query(
                `UPDATE products SET stock = stock - ${data.items[i].quantity} WHERE id = '${data.items[i].productId}'`
            )
        }

        // 发邮件
        const user = await this.db.query(
            `SELECT * FROM users WHERE id = '${data.userId}'`
        )
        await this.mailer.send(
            user.email,
            'Order Confirmed',
            `Your order ${orderId} total: ${total}`
        )

        return { orderId, total }
    }
}

基于上面识别的问题，帮我制定一个安全的重构计划。

原则：
1. 每一步都保持代码可运行
2. 优先处理安全风险（SQL 注入）
3. 其次处理数据一致性风险（无事务）
4. 最后做代码结构优化

给出具体的步骤顺序，每步的目标是什么，改完后如何验证没有引入新问题。

Step 1: 消除 SQL 注入（用参数化查询或 ORM 替换拼接 SQL）
        验证：接口功能不变，无 SQL 注入漏洞

Step 2: 引入事务（用数据库事务包裹插入订单+扣库存操作）
        验证：任一步骤失败时整体回滚，不产生脏数据

Step 3: 消灭魔法数字（提取常量和枚举）
        验证：代码逻辑不变，status/折扣规则有明确命名

Step 4: 拆分函数（每个函数只做一件事）
        验证：单元测试覆盖每个子函数

Step 5: 加类型声明（消灭 any）
        验证：TypeScript 编译通过，无类型错误

@src/legacy/order.service.ts 的 processOrder 方法承担了太多职责。

帮我按以下方式拆分，不改变业务逻辑，只做结构重组：

1. validateOrderInput(data)：校验输入参数
2. calculateOrderItems(items)：查询商品信息，返回商品详情+价格小计
   （同时返回 insufficientStock 的商品列表）
3. calculateDiscount(subtotal)：根据总价计算折扣，返回最终金额
4. createOrderWithItems(userId, items, total)：在事务中创建订单+扣库存
5. sendOrderConfirmation(userId, orderId, total)：发送确认邮件（异步）
6. processOrder(data)：调用上面各步骤，组织完整流程

每个方法要有明确的参数类型和返回类型，不能用 any。

// ✅ 重构后：清晰的 NestJS Service
import {
    Injectable,
    BadRequestException,
    ConflictException,
} from '@nestjs/common'
import { PrismaService } from '../../prisma/prisma.service'
import { MailService } from '../mail/mail.service'
import { CreateOrderDto, OrderItemDto } from './dto/create-order.dto'
import { BusinessException } from '../../common/exceptions/business.exception'
import { ErrorCode } from '../../common/constants/error-code'

// 折扣规则常量
const DISCOUNT_RULES = [
    { threshold: 1000, rate: 0.9 },
    { threshold: 500, rate: 0.95 },
] as const

// 订单状态枚举
enum OrderStatus {
    PENDING = 'PENDING',
    PAID = 'PAID',
    CANCELLED = 'CANCELLED',
}

interface OrderItemDetail {
    productId: string
    productName: string
    price: number
    quantity: number
    subtotal: number
}

@Injectable()
export class OrderService {
    constructor(
        private readonly prisma: PrismaService,
        private readonly mailService: MailService
    ) {}

    async createOrder(
        dto: CreateOrderDto
    ): Promise<{ orderId: string; total: number }> {
        const itemDetails = await this.resolveOrderItems(dto.items)
        const subtotal = itemDetails.reduce(
            (sum, item) => sum + item.subtotal,
            0
        )
        const total = this.applyDiscount(subtotal)
        const orderId = await this.persistOrder(dto.userId, itemDetails, total)

        // 异步发送邮件，不阻塞响应
        this.mailService
            .sendOrderConfirmation(dto.userId, orderId, total)
            .catch((err) => {
                // 邮件失败不影响订单创建，只记录日志
                this.logger.error(
                    { orderId, error: err.message },
                    'Failed to send order confirmation'
                )
            })

        return { orderId, total }
    }

    private async resolveOrderItems(
        items: OrderItemDto[]
    ): Promise<OrderItemDetail[]> {
        const productIds = items.map((item) => item.productId)

        const products = await this.prisma.product.findMany({
            where: { id: { in: productIds }, isDeleted: false },
        })

        const productMap = new Map(products.map((p) => [p.id, p]))

        return items.map((item) => {
            const product = productMap.get(item.productId)
            if (!product) {
                throw new BusinessException(ErrorCode.PRODUCT_NOT_FOUND)
            }
            if (product.stock < item.quantity) {
                throw new BusinessException(ErrorCode.INSUFFICIENT_STOCK)
            }
            return {
                productId: item.productId,
                productName: product.name,
                price: product.price,
                quantity: item.quantity,
                subtotal: product.price * item.quantity,
            }
        })
    }

    private applyDiscount(subtotal: number): number {
        const rule = DISCOUNT_RULES.find((r) => subtotal >= r.threshold)
        return rule ? subtotal * rule.rate : subtotal
    }

    private async persistOrder(
        userId: string,
        items: OrderItemDetail[],
        total: number
    ): Promise<string> {
        return this.prisma.$transaction(async (tx) => {
            const order = await tx.order.create({
                data: {
                    userId,
                    total,
                    status: OrderStatus.PENDING,
                    items: {
                        create: items.map((item) => ({
                            productId: item.productId,
                            quantity: item.quantity,
                            price: item.price,
                        })),
                    },
                },
            })

            // 批量扣减库存
            await Promise.all(
                items.map((item) =>
                    tx.product.update({
                        where: { id: item.productId },
                        data: { stock: { decrement: item.quantity } },
                    })
                )
            )

            return order.id
        })
    }
}

在重构 processOrder 之前，先帮我为现有的代码写集成测试，
覆盖正常下单流程，用内存数据库模拟，这样重构后可以跑测试验证行为没变。

git commit -m "refactor: extract resolveOrderItems from processOrder"
git commit -m "refactor: wrap order creation in transaction"
git commit -m "refactor: replace magic numbers with constants"

对比 @src/legacy/order.service.ts（重构前）和
@src/modules/order/order.service.ts（重构后），

确认以下方面的语义是否完全一致：
1. 输入校验的条件
2. 折扣计算规则
3. 数据库操作的内容（哪些表、哪些字段）
4. 邮件发送的时机和参数

找出任何可能的行为差异。

理解代码 → 识别坏味道 → 制定计划 → 小步执行 → 测试验证