NestJS 中集成 Prisma 的最佳实践

在 NestJS 项目中集成 Prisma ORM 时，开发者常常会遇到如何优雅封装 Prisma 客户端的问题。本文将深入探讨几种实现方案，并分析其优缺点，帮助开发者选择最适合自己项目的方案。

基础集成方案

最简单的集成方式是在服务中直接实例化 PrismaClient：

import { Injectable } from '@nestjs/common';
import { PrismaClient } from '@prisma/client';

@Injectable()
export class UserService {
  private prisma = new PrismaClient();
  
  async getUsers() {
    return this.prisma.user.findMany();
  }
}

这种方案虽然简单直接，但存在几个明显问题：

1. 每个服务都创建自己的 PrismaClient 实例，导致连接池浪费
2. 缺乏统一的配置管理
3. 难以实现全局的 Prisma 扩展

进阶方案：Prisma 服务封装

更优雅的做法是将 PrismaClient 封装为可注入的服务：

import { Injectable, OnModuleInit, OnModuleDestroy } from '@nestjs/common';
import { PrismaClient } from '@prisma/client';

@Injectable()
export class PrismaService extends PrismaClient 
  implements OnModuleInit, OnModuleDestroy {
  
  async onModuleInit() {
    await this.$connect();
  }

  async onModuleDestroy() {
    await this.$disconnect();
  }
}

然后在模块中注册为全局服务：

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

@Module({
  providers: [PrismaService],
  exports: [PrismaService],
})
export class PrismaModule {}

这种方案解决了连接池共享问题，但仍缺乏对 Prisma 扩展的支持。

高级方案：支持扩展的 Prisma 服务

为了实现 Prisma 的扩展功能，我们需要更复杂的封装：

import { Injectable, OnModuleInit, OnModuleDestroy } from '@nestjs/common';
import { Prisma, PrismaClient } from '@prisma/client';

@Injectable()
export class PrismaService extends PrismaClient 
  implements OnModuleInit, OnModuleDestroy {
  
  private readonly extensions = this.$extends({
    model: {
      $allModels: {
        async exists<T>(this: T, where: Prisma.Args<T, 'findFirst'>['where']) {
          const context = Prisma.getExtensionContext(this);
          const result = await (context as any).findFirst({ where });
          return Boolean(result);
        }
      }
    }
  });

  constructor() {
    super();
    Object.assign(this, this.extensions);
  }

  // ...生命周期方法
}

这种实现方式通过混入(Mixin)模式将扩展功能合并到 PrismaClient 实例中，但类型推导会变得复杂。

最佳实践方案

结合 NestJS 的依赖注入系统和 Prisma 的扩展功能，推荐以下实现：

1. 分离 Prisma 客户端和扩展逻辑
2. 使用符号令牌(Symbol Token)注入
3. 提供完整的类型支持

// prisma.extension.ts
export const prismaExtension = (client: PrismaClient) => {
  return client.$extends({
    model: {
      $allModels: {
        async exists<T>(this: T, where: Prisma.Args<T, 'findFirst'>['where']) {
          const context = Prisma.getExtensionContext(this);
          const result = await (context as any).findFirst({ where });
          return Boolean(result);
        }
      }
    }
  });
};

export type ExtendedPrismaClient = ReturnType<typeof prismaExtension>;

// prisma.service.ts
import { Injectable, OnModuleInit, OnModuleDestroy } from '@nestjs/common';
import { PrismaClient } from '@prisma/client';
import { prismaExtension, ExtendedPrismaClient } from './prisma.extension';

@Injectable()
export class PrismaService 
  extends PrismaClient
  implements OnModuleInit, OnModuleDestroy {
  
  private readonly extensions: ExtendedPrismaClient;
  
  constructor() {
    super();
    this.extensions = prismaExtension(this);
  }
  
  get extended() {
    return this.extensions;
  }
  
  // ...生命周期方法
}

// prisma.module.ts
import { DynamicModule, Module, Provider } from '@nestjs/common';
import { PrismaService } from './prisma.service';
import { ExtendedPrismaClient } from './prisma.extension';

export const PRISMA_CLIENT = Symbol('PRISMA_CLIENT');

@Module({})
export class PrismaModule {
  static forRoot(): DynamicModule {
    const prismaProvider: Provider = {
      provide: PRISMA_CLIENT,
      useFactory: (prisma: PrismaService) => prisma.extended,
      inject: [PrismaService],
    };

    return {
      module: PrismaModule,
      providers: [PrismaService, prismaProvider],
      exports: [prismaProvider],
      global: true,
    };
  }
}

使用示例

在服务中注入扩展后的 Prisma 客户端：

import { Injectable, Inject } from '@nestjs/common';
import { PRISMA_CLIENT, ExtendedPrismaClient } from './prisma.module';

@Injectable()
export class UserService {
  constructor(
    @Inject(PRISMA_CLIENT) 
    private readonly prisma: ExtendedPrismaClient
  ) {}

  async checkUserExists(id: string) {
    return this.prisma.user.exists({ where: { id } });
  }
}

总结

在 NestJS 中集成 Prisma 时，推荐采用以下最佳实践：

1. 将 PrismaClient 封装为可注入服务
2. 使用符号令牌提供类型安全的注入
3. 分离基础客户端和扩展逻辑
4. 提供完整的类型定义支持
5. 考虑使用全局模块减少重复配置

这种架构既保持了代码的整洁性，又提供了强大的类型支持和扩展能力，是大型 NestJS 项目集成 Prisma 的理想选择。