Prisma Client Adapter and NestJS PrismaService

PHASE 09 / BOOK 06

Prisma Client, PrismaPg & NestJS PrismaService Turn generated types into reusable backend infrastructure

NestJS

PrismaService

Prisma Client

PrismaPg driver adapter

Supabase PostgreSQL

Figure - The database access stack introduced in Phase 09

Course rule: Prisma CLI, @prisma/client and @prisma/adapter-pg are locked to 7.9.1. Newer Prisma releases are not substituted halfway through the course.

1. Generate Prisma Client From: taskflow\apps\api

pnpm exec prisma generate

Generation reads schema.prisma and emits a client tailored to the current models. Whenever the schema or generator configuration changes, regenerate explicitly. This course does not depend on migrate dev implicitly generating it.

schema.prisma

pnpm exec prisma generate

src/generated/prisma

PrismaClient type-safe API

Figure 1 - Client generation is a build step, not a database migration

2. Prisma 7 Requires a Driver Adapter For direct PostgreSQL connections, Prisma 7 uses a database driver adapter. PrismaPg is the bridge between the generated Prisma Client and the pg driver connection pool.

Prisma Client

PrismaPg adapter

pg driver/pool

PostgreSQL

Figure 2 - Runtime connectivity in Prisma 7

3. Wrap the Client in a NestJS Provider apps/api/src/prisma/prisma.service.ts

import { Injectable, OnModuleDestroy, OnModuleInit } from "@nestjs/common";
import { ConfigService } from "@nestjs/config";
import { PrismaPg } from "@prisma/adapter-pg";
import { PrismaClient } from "../generated/prisma/client";

@Injectable()
export class PrismaService
extends PrismaClient
implements OnModuleInit, OnModuleDestroy
{
constructor(config: ConfigService) {
const connectionString = config.getOrThrow<string>("DATABASE_URL");
const adapter = new PrismaPg({ connectionString });
super({ adapter });
}

async onModuleInit() {
await this.$connect();
}

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

The constructor reads DATABASE_URL through ConfigService, creates the adapter, and passes it to PrismaClient. The service then participates in Nest lifecycle hooks.

4. Export the Provider apps/api/src/prisma/prisma.module.ts

import { Global, Module } from "@nestjs/common";
import { PrismaService } from "./prisma.service";

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

Marking PrismaModule global avoids repetitive imports as features grow, but the important design point is still one shared PrismaService instance rather than creating a new PrismaClient in each request or service.

5. Load Trusted Backend Configuration apps/api/src/app.module.ts

import { Module } from "@nestjs/common";
import { ConfigModule } from "@nestjs/config";
import { HealthModule } from "./health/health.module";
import { TodosModule } from "./todos/todos.module";
import { PrismaModule } from "./prisma/prisma.module";

@Module({ imports: [ ConfigModule.forRoot({ isGlobal: true }), PrismaModule, HealthModule, TodosModule, ], }) export class AppModule {}

6. Why One Client Instance Matters Each Prisma Client with a PostgreSQL adapter can own a connection pool. Creating clients repeatedly can exhaust database connections. NestJS dependency injection gives us a natural process-wide provider.

ANTI-PATTERN Do not put new PrismaClient({ adapter }) inside every controller method. That mixes infrastructure with HTTP logic and can create many connection pools.

7. Connectivity Probe Without Building CRUD Yet Use only as a connectivity check

// Temporary diagnostic inside a service or one-off script const result = await prisma.$queryRaw`SELECT 1 AS ok`; console.log(result);

A raw SELECT 1 verifies runtime connectivity without skipping ahead into Phase 11 CRUD architecture.

Checkpoint • Generated client exists.

• NestJS imports the generated client from the configured path.

• PrismaPg receives DATABASE_URL.

• PrismaService is injectable and uses one client instance.

• The API can connect and disconnect cleanly.