从单体到模块化：不要急着拆微服务

// ❌ 坏做法：订单服务直接引用支付模块的 Repository
// OrderService.ts
import { PaymentRepository } from '@/repositories/PaymentRepository'
 
export class OrderService {
  constructor(
    private paymentRepo: PaymentRepository,  // 直接跨模块引用
    private orderRepo: OrderRepository,
  ) {}
 
  async createOrder(dto: CreateOrderDTO) {
    const order = await this.orderRepo.create(dto)
    // 订单模块直接写支付表
    await this.paymentRepo.create({
      orderId: order.id,
      userId: order.userId,
      amount: order.totalAmount,
      status: 'PENDING',
    })
    return order
  }
}

// ✅ 好做法：通过公开接口和事件通信
// modules/payment/paymentModule.ts
// 支付模块暴露一个明确的接口
export interface PaymentService {
  createPayment(params: {
    orderId: string
    userId: string
    amount: number
  }): Promise<PaymentResult>
}
 
// modules/order/OrderService.ts
// 订单模块只依赖抽象接口，不关心支付实现
export class OrderService {
  constructor(
    private paymentService: PaymentService,  // 依赖接口而非具体实现
    private orderRepo: OrderRepository,
    private eventBus: EventBus,
  ) {}
 
  async createOrder(dto: CreateOrderDTO) {
    const order = await this.orderRepo.create(dto)
 
    // 通过接口调用，而非直接操作对方的数据库
    const paymentResult = await this.paymentService.createPayment({
      orderId: order.id,
      userId: order.userId,
      amount: order.totalAmount,
    })
 
    // 发布事件，其他模块按需订阅
    await this.eventBus.publish('order.created', {
      orderId: order.id,
      status: order.status,
      paymentId: paymentResult.id,
    })
 
    return order
  }
}

// ❌ 坏做法：多个模块直接写同一张表
// InventoryService.ts
export class InventoryService {
  async deductStock(orderId: string, items: OrderItem[]) {
    // 直接操作库存表，订单模块也在写这张表
    await db.inventory.update({
      where: { itemId: items[0].itemId },
      data: { stock: { decrement: items[0].quantity } },
    })
  }
}

// ✅ 好做法：每个模块拥有自己的表，通过事件同步
// modules/inventory/InventoryService.ts
export class InventoryService {
  constructor(
    private inventoryRepo: InventoryRepository,  // 只操作自己模块的表
    private eventBus: EventBus,
  ) {}
 
  // 库存模块独占 inventory 表的写入权
  async handleOrderPlaced(event: OrderPlacedEvent) {
    const result = await this.inventoryRepo.deductBatch(
      event.items.map(item => ({
        itemId: item.itemId,
        quantity: item.quantity,
      })),
    )
 
    // 通过事件通知其他模块
    await this.eventBus.publish('inventory.deducted', {
      orderId: event.orderId,
      results: result,
    })
  }
}

// ❌ 坏做法：全局共享一张大宽表
// 任何模块都可以直接查 users 表的任何字段
const user = await db.users.findUnique({
  where: { id: userId },
  // 查了 20 个字段，其中 18 个跟当前业务无关
  select: {
    id: true, email: true, password: true, nickname: true,
    avatar: true, phone: true, role: true, address_id: true,
    payment_pref: true, created_at: true, // ... 还有 10 个
  },
})

// ✅ 好做法：每个子模块只暴露自己领域的查询接口
// modules/auth/AuthQueryService.ts
export class AuthQueryService {
  // 只暴露认证相关的信息
  async getCredentials(userId: string) {
    return db.auth_credentials.findUnique({
      where: { userId },
      select: { email: true, passwordHash: true, mfaEnabled: true },
    })
  }
}
 
// modules/profile/ProfileQueryService.ts
export class ProfileQueryService {
  // 只暴露个人资料
  async getProfile(userId: string) {
    return db.user_profiles.findUnique({
      where: { userId },
      select: { nickname: true, avatarUrl: true, bio: true },
    })
  }
}
 
// 业务代码只请求自己需要的模块接口
const profile = await profileQueryService.getProfile(userId)

// ❌ 坏做法：拆分前，通知处理在主进程内，同步阻塞
// modules/notification/EmailNotifier.ts
export class EmailNotifier {
  constructor(
    private emailClient: EmailClient,
    private templateEngine: TemplateEngine,
  ) {}
 
  // 同步发送，第三方超时会阻塞调用方
  async sendOrderConfirmation(userId: string, order: OrderInfo) {
    const html = await this.templateEngine.render('order-confirm', { order })
    // 直接调用外部 API，没有超时保护和重试机制
    await this.emailClient.send({
      to: userId,
      subject: `订单 ${order.id} 确认`,
      html,
    })
  }
}

// ✅ 拆分后：异步消费 + 超时保护 + 独立部署
// services/notification/NotificationWorker.ts
export class NotificationWorker {
  constructor(
    private messageQueue: MessageQueue,
    private emailClient: EmailClient,
    private retryPolicy: RetryPolicy,
    private circuitBreaker: CircuitBreaker,  // 熔断器
  ) {}
 
  async start() {
    // 独立消费者，不影响主应用线程
    await this.messageQueue.consume('order.created', async (event) => {
      // 带超时和重试的发送
      await this.retryPolicy.execute(
        () => this.circuitBreaker.execute(
          () => this.emailClient.send({
            to: event.userId,
            subject: `订单 ${event.orderId} 确认`,
            html: event.renderedHtml,  // 渲染在主进程完成
          }),
        ),
        { maxRetries: 3, backoff: 'exponential' },
      )
    })
  }
}