### Install Dependencies and Start Nest App

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/examples/extensions/README.md

Install project dependencies and start the development server for the NestJS application.

```sh
npm i

npm run start:dev
```

--------------------------------

### Install Driver Adapter for SQLite

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/rust-free-and-driver-adapter.md

Install the appropriate driver adapter for your database. This example shows the installation for SQLite using `@prisma/adapter-better-sqlite3`.

```bash
npm install @prisma/adapter-better-sqlite3
```

--------------------------------

### Setup Prisma with npm

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/installation.md

Install Prisma as a development dependency and the Prisma client, then initialize Prisma in your NestJS application.

```sh
npm i -D prisma
npm install @prisma/client

npx prisma init
```

--------------------------------

### Start Development Server

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/examples/fastify/README.md

Start the NestJS development server with Fastify.

```sh
npm run start:dev
```

--------------------------------

### Install Prisma Read Replica Extension

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/prisma-client-extensions.md

Install the @prisma/extension-read-replicas package using npm.

```bash
npm i @prisma/extension-read-replicas
```

--------------------------------

### Install Rust-free Prisma Client Adapter

Source: https://context7.com/notiz-dev/nestjs-prisma/llms.txt

Install the appropriate driver adapter for your database to enable the Rust-free Prisma Client. This command installs the adapter for better-sqlite3.

```bash
npm install @prisma/adapter-better-sqlite3   # or the adapter for your database
```

--------------------------------

### Install Prisma Pagination Extension

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/prisma-client-extensions.md

Install the prisma-extension-pagination package using npm.

```bash
npm i prisma-extension-pagination
```

--------------------------------

### Install Project Dependencies

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/examples/graphql/README.md

Run this command in your terminal to install all necessary project dependencies.

```bash
npm install
```

--------------------------------

### Example Schematic Output

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/schematics.md

This output demonstrates the typical result of running the nestjs-prisma schematic, including package installations and configuration steps.

```bash
✔ Package installation in progress... ☕
Starting library setup...
? Which datasource provider do you want to use for `prisma init`? postgresql
? Do you like to Dockerize your application? (Supports postgresql and mysql) Yes
    ✅️ Added prisma@latest
    ✅️ Added @prisma/client@latest
    ✅️ Added Prisma scripts [6]
    ✅️ Added Prisma Seed script
    ✅️ Added Docker file
    ✅️ Added Docker Compose and .env
    ✅️ Add "prisma" directory to "excludes" in tsconfig.build.json
CREATE .dockerignore (42 bytes)
CREATE Dockerfile (455 bytes)
CREATE .env (642 bytes)
CREATE docker-compose.yml (497 bytes)
UPDATE package.json (2754 bytes)
UPDATE tsconfig.build.json (130 bytes)
✔ Packages installed successfully.
✔ Packages installed successfully.
    ✅️ Initialized Prisma - Datasource postgresql
```

--------------------------------

### Seed Example Database

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/examples/extensions/README.md

Seed the example database with initial data using the Prisma CLI.

```sh
npx prisma db seed
```

--------------------------------

### Install Dependencies

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/examples/fastify/README.md

Install project dependencies using npm.

```sh
npm i
```

--------------------------------

### Install nestjs-prisma manually

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/README.md

Install the `nestjs-prisma` library using npm or yarn.

```sh
# npm
npm install nestjs-prisma

# yarn
yarn add nestjs-prisma
```

--------------------------------

### Install Project Dependencies

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/examples/driver/README.md

Run this command in your project's root directory to install all necessary Node.js dependencies.

```bash
$ npm install
```

--------------------------------

### Manual installation of nestjs-prisma

Source: https://context7.com/notiz-dev/nestjs-prisma/llms.txt

Manually install nestjs-prisma and its peer dependencies using npm or yarn, followed by Prisma initialization.

```bash
npm install nestjs-prisma
npm install @prisma/client
npm install -D prisma
npx prisma init
```

--------------------------------

### Run NestJS Application

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/examples/graphql/README.md

Commands to start the NestJS application in different modes. Use 'start:dev' for development with watch mode and 'start:prod' for production.

```bash
npm run start
```

```bash
npm run start:dev
```

```bash
npm run start:prod
```

--------------------------------

### Instantiate Prisma Client with Driver Adapter

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/rust-free-and-driver-adapter.md

Create a `PrismaClient` instance from your custom output path and configure it with the installed driver adapter. The database URL can be set directly or via environment variables.

```typescript
import { PrismaBetterSQLite3 } from '@prisma/adapter-better-sqlite3';
import { PrismaClient } from './generated/prisma/client';

const adapter = new PrismaBetterSQLite3({ url: 'file:./prisma/dev.db' });
export const prisma = new PrismaClient({ adapter });

export type PrismaClientType = typeof prisma;
```

--------------------------------

### Add Prisma Skipping Dependency Installation

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/schematics.md

The `--skipInstall` flag prevents the schematic from automatically installing dependency packages. This allows for manual control over the installation process.

```bash
nest add nestjs-prisma --skipInstall
```

--------------------------------

### Install Angular Schematics CLI

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/README.md

Install the Angular Schematics CLI globally to manage schematics.

```bash
npm i -g @angular-devkit/schematics-cli
```

--------------------------------

### Install nestjs-prisma Manually with npm

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/installation.md

Add the `nestjs-prisma` library to your NestJS project using npm.

```sh
npm install nestjs-prisma
```

--------------------------------

### Initialize Prisma Client with Driver Adapter

Source: https://context7.com/notiz-dev/nestjs-prisma/llms.txt

Instantiate the Prisma Client using the chosen driver adapter. This setup is crucial for running Prisma without the Rust query engine binary and should be exported for use in NestJS modules.

```typescript
// src/prisma.extension.ts
import { PrismaBetterSQLite3 } from '@prisma/adapter-better-sqlite3';
import { PrismaClient } from './generated/prisma/client';

const adapter = new PrismaBetterSQLite3({ url: process.env.DATABASE_URL ?? 'file:./prisma/dev.db' });
export const prisma = new PrismaClient({ adapter });
export type PrismaClientType = typeof prisma;
```

--------------------------------

### Add nestjs-prisma Automatically

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/installation.md

Use the `nest add` command for a streamlined setup of the library, Prisma, and optionally Docker.

```sh
nest add nestjs-prisma
```

--------------------------------

### Add nestjs-prisma with specific Prisma version and custom service

Source: https://context7.com/notiz-dev/nestjs-prisma/llms.txt

Install nestjs-prisma with a specific Prisma version and enable the addition of a custom Prisma service.

```bash
nest add nestjs-prisma --prismaVersion 5.22.0 --addPrismaService
```

--------------------------------

### Implement Pagination with Prisma Extension

Source: https://context7.com/notiz-dev/nestjs-prisma/llms.txt

Install `prisma-extension-pagination` and use `CustomPrismaModule.forRootAsync` to provide the extended client. The `paginate()` method with `withPages` allows for easy pagination.

```bash
npm i prisma-extension-pagination
```

```typescript
// src/prisma.extension.ts
import { PrismaClient } from '@prisma/client';
import pagination from 'prisma-extension-pagination';

export const extendedPrismaClient = new PrismaClient().$extends(pagination());
export type ExtendedPrismaClient = typeof extendedPrismaClient;

// src/users.service.ts
import {
  Inject,
  Injectable,
} from '@nestjs/common';
import { CustomPrismaService } from 'nestjs-prisma';
import { type ExtendedPrismaClient } from './prisma.extension';

@Injectable()
export class UsersService {
  constructor(
    @Inject('PrismaService')
    private readonly prisma: CustomPrismaService<ExtendedPrismaClient>,
  ) {}

  async findPage(page = 1, limit = 10) {
    const [users, meta] = await this.prisma.client.user
      .paginate()
      .withPages({ limit, page, includePageCount: true });
    // meta: { currentPage, isFirstPage, isLastPage, previousPage, nextPage, pageCount, totalCount }
    return { users, meta };
  }
}
```

--------------------------------

### Install nestjs-prisma Manually with yarn

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/installation.md

Add the `nestjs-prisma` library to your NestJS project using yarn.

```sh
yarn add nestjs-prisma
```

--------------------------------

### Run NestJS Application

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/examples/driver/README.md

Commands to start the NestJS application in different modes. Use 'start:dev' for development with watch mode.

```bash
# development
$ npm run start

# watch mode
$ npm run start:dev

# production mode
$ npm run start:prod
```

--------------------------------

### Configure Read Replicas with Prisma Extension

Source: https://context7.com/notiz-dev/nestjs-prisma/llms.txt

Install `@prisma/extension-read-replicas` and configure it using `CustomPrismaModule.forRootAsync`. Reads will go to the replica URL, while writes use the primary URL. Use `$primary()` to force writes to the primary.

```bash
npm i @prisma/extension-read-replicas
```

```typescript
// src/prisma.extension.ts
import { PrismaClient } from '@prisma/client';
import { readReplicas } from '@prisma/extension-read-replicas';

export const extendedPrismaClient = new PrismaClient().$extends(
  readReplicas({ url: process.env.DATABASE_REPLICA_URL }),
);
export type ExtendedPrismaClient = typeof extendedPrismaClient;

// src/app.service.ts — reads go to replica, writes go to primary
@Injectable()
export class AppService {
  constructor(
    @Inject('PrismaService')
    private readonly prisma: CustomPrismaService<ExtendedPrismaClient>,
  ) {}

  users()              { return this.prisma.client.user.findMany(); }           // → replica
  userPrimary(id: string) { return this.prisma.client.$primary().user.findUnique({ where: { id } }); } // → primary
  create(email: string)   { return this.prisma.client.user.create({ data: { email } }); }              // → primary
}
```

--------------------------------

### Configure Rust-free Prisma Client in schema.prisma

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/rust-free-and-driver-adapter.md

Configure your Prisma schema to use the `prisma-client` provider and specify a custom output directory. This setup avoids including the Rust query engine binary in your project.

```prisma
generator client {
  provider     = "prisma-client"
  output       = "../src/generated/prisma"
  engineType   = "client"
  moduleFormat = "cjs"
}

datasource db {
  provider = "sqlite"
  url      = "file:dev.db"
}
```

--------------------------------

### Add Custom Prisma Service to NestJS Project

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/custom-prisma-service.md

Use this command to install the `nestjs-prisma` package and generate a custom `PrismaService` and `PrismaModule`. This is useful for further customizations.

```bash
nest add nestjs-prisma -- --addPrismaService
```

--------------------------------

### Astro Project Commands

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/README.md

Lists essential npm commands for managing an Astro project, including installation, development server, building for production, and previewing.

```bash
npm install
```

```bash
npm run dev
```

```bash
npm run build
```

```bash
npm run preview
```

```bash
npm run astro ...
```

```bash
npm run astro --help
```

--------------------------------

### Deploy NestJS Application with Mau

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/examples/driver/README.md

Install the Mau CLI globally and deploy your NestJS application to AWS. Mau simplifies the deployment process.

```bash
$ npm install -g @nestjs/mau
$ mau deploy
```

--------------------------------

### Add Prisma with Specific Version

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/schematics.md

Use the `--prismaVersion` flag to install a specific version of Prisma. This is useful for managing dependencies and ensuring compatibility.

```bash
nest add nestjs-prisma --prismaVersion 3.2.1
```

--------------------------------

### Create Prisma Extension

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/prisma-client-extensions.md

Define a custom Prisma extension by extending the PrismaClient. This example adds a `findByEmail` method to the `user` model.

```typescript
import { PrismaClient } from '@prisma/client';

export const extendedPrismaClient = new PrismaClient().$extends({
  model: {
    user: {
      findByEmail: async (email: string) => {
        return extendedPrismaClient.user.findFirstOrThrow({ where: { email } });
      },
    },
  },
});

export type ExtendedPrismaClient = typeof extendedPrismaClient;
```

--------------------------------

### Apply Prisma Middleware in PrismaModule

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/prisma-middleware.md

Configure PrismaModule to use custom middleware by providing an array of middleware functions to `prismaServiceOptions.middlewares`. This example shows a basic middleware that logs before and after a query.

```typescript
import {
  Module
} from '@nestjs/common';
import { PrismaModule } from 'nestjs-prisma';

@Module({
  imports: [
    PrismaModule.forRoot({
      prismaServiceOptions: {
        middlewares: [
          async (params, next) => {
            // Before query: change params
            const result = await next(params);
            // After query: result
            return result;
          },
        ],
      },
    }),
  ],
})
export class AppModule {}
```

--------------------------------

### CustomPrismaModule for Single Custom Client

Source: https://context7.com/notiz-dev/nestjs-prisma/llms.txt

Use `CustomPrismaModule` and `CustomPrismaService` when Prisma Client is generated to a non-default location or when multiple clients are needed. This example shows setting up a single custom client with a unique injection token.

```prisma
// prisma/schema.prisma (snippet)
// generator client {
//   provider = "prisma-client-js"
//   output   = "../node_modules/@myorg/prisma-auth"
// }
```

```typescript
// src/app.module.ts
import { Module } from '@nestjs/common';
import { CustomPrismaModule } from 'nestjs-prisma';
import { PrismaClient } from '@myorg/prisma-auth';

@Module({
  imports: [
    CustomPrismaModule.forRoot({
      name: 'PrismaServiceAuth',   // unique injection token
      client: new PrismaClient(),
    }),
  ],
})
export class AppModule {}

// src/app.service.ts
import { Inject, Injectable } from '@nestjs/common';
import { CustomPrismaService } from 'nestjs-prisma';
import { PrismaClient } from '@myorg/prisma-auth';

@Injectable()
export class AppService {
  constructor(
    @Inject('PrismaServiceAuth')
    private readonly prisma: CustomPrismaService<PrismaClient>,
  ) {}

  users() {
    return this.prisma.client.user.findMany();
  }
}
```

--------------------------------

### Custom Error Code Mapping with providePrismaClientExceptionFilter()

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/exception-filter.md

Configure PrismaClientExceptionFilter with custom error mappings using the providePrismaClientExceptionFilter() helper function in AppModule for a streamlined setup.

```typescript
//src/app.module.ts
import { HttpStatus, Module } from '@nestjs/common';
import { providePrismaClientExceptionFilter } from 'nestjs-prisma';

@Module({
  providers: [
    providePrismaClientExceptionFilter({
      // Prisma Error Code: HTTP Status Response
      P2000: HttpStatus.BAD_REQUEST,
      P2002: HttpStatus.CONFLICT,
      P2025: HttpStatus.NOT_FOUND,
    }),
  ],
})
export class AppModule {}

```

--------------------------------

### Prisma CLI Commands

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/examples/basics/README.md

Run these commands to set up your database schema and seed the database.

```sh
npx prisma migrate dev
```

```sh
npx prisma db seed
```

```sh
npm i

npm run start:dev
```

--------------------------------

### Build and Run Schematics

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/README.md

Build the schematics and then run them using the `schematics` command. Use `--debug false` or `--dry-run false` to execute.

```bash
npm run build:schematics
# or
npm run dev:schematics

# dry-run
schematics .:nest-add

# execute schematics
schematics .:nest-add --debug false
# or
schematics .:nest-add --dry-run false
```

--------------------------------

### Enable Client Extensions Preview Feature

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/prisma-client-extensions.md

Configure your `schema.prisma` file to enable the `clientExtensions` preview feature. This is necessary for versions prior to 4.16.0. Remember to regenerate your Prisma Client after making this change.

```prisma
datasource db {
  provider = "sqlite"
  url      = env("DATABASE_URL")
}

generator client {
  provider        = "prisma-client-js"
  previewFeatures = ["clientExtensions"]
}

model User {
  id    String  @id @default(cuid())
  email String  @unique
  name  String?
}
```

--------------------------------

### Configure PrismaModule with forRoot (synchronous)

Source: https://context7.com/notiz-dev/nestjs-prisma/llms.txt

Register PrismaService synchronously using `PrismaModule.forRoot()`. Configure global availability, explicit connection, and Prisma client options.

```typescript
// src/app.module.ts
import { Module } from '@nestjs/common';
import { PrismaModule } from 'nestjs-prisma';

@Module({
  imports: [
    PrismaModule.forRoot({
      // Make PrismaService available application-wide without re-importing
      isGlobal: true,
      prismaServiceOptions: {
        // Create the connection pool immediately on startup instead of lazily
        explicitConnect: true,
        // Pass any PrismaClientOptions directly
        prismaOptions: {
          log: ['query', 'info', 'warn', 'error'],
          datasources: {
            db: { url: process.env.DATABASE_URL },
          },
        },
      },
    }),
  ],
})
export class AppModule {}

```

--------------------------------

### Async Configuration with ConfigService Injection

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/configuration.md

Demonstrates asynchronous configuration of `PrismaModule` using `useFactory` and injecting `ConfigService`. This enables loading Prisma options, including database URLs and connection settings, from environment variables.

```typescript
import {
  Module
} from '@nestjs/common';
import {
  ConfigModule,
  ConfigService
} from '@nestjs/config';
import {
  PrismaModule
} from 'nestjs-prisma';

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true,
    }),
    PrismaModule.forRootAsync({
      isGlobal: true,
      useFactory: async (configService: ConfigService) => {
        return {
          prismaOptions: {
            log: [configService.get('log')],
            datasources: {
              db: {
                url: configService.get('DATABASE_URL'),
              },
            },
          },
          explicitConnect: configService.get('explicit'),
        };
      },
      inject: [ConfigService],
    }),
  ],
})
export class AppModule {}
```

--------------------------------

### Global PrismaClientExceptionFilter Setup

Source: https://context7.com/notiz-dev/nestjs-prisma/llms.txt

Implement `PrismaClientExceptionFilter` globally in your NestJS application to catch Prisma-specific errors and map them to appropriate HTTP status codes. This prevents generic 500 errors for common Prisma issues.

```typescript
// src/main.ts
import { HttpAdapterHost, NestFactory } from '@nestjs/core';
import { HttpStatus } from '@nestjs/common';
import { AppModule } from './app.module';
import { PrismaClientExceptionFilter } from 'nestjs-prisma';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  const { httpAdapter } = app.get(HttpAdapterHost);
  app.useGlobalFilters(
    new PrismaClientExceptionFilter(httpAdapter, {
      // Override or extend the default error code → HTTP status mapping
      P2000: HttpStatus.BAD_REQUEST,   // value too long for column
      P2002: HttpStatus.CONFLICT,      // unique constraint violation
      P2025: HttpStatus.NOT_FOUND,     // record not found
      P2003: HttpStatus.BAD_REQUEST,   // foreign key constraint failure
    }),
  );

  await app.listen(3000);
}
bootstrap();
```

--------------------------------

### Apply Default Logging Middleware

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/logging-middleware.md

Use `loggingMiddleware` to enable default query logging. This is typically configured within the `PrismaModule.forRoot` options.

```typescript
import {
  Module
} from '@nestjs/common';
import { PrismaModule, loggingMiddleware } from 'nestjs-prisma';

@Module({
  imports: [
    PrismaModule.forRoot({
      prismaServiceOptions: {
        middlewares: [loggingMiddleware()],
      },
    }),
  ],
})
export class AppModule {}
```

--------------------------------

### Configure Prisma Schema for Driver Adapter

Source: https://context7.com/notiz-dev/nestjs-prisma/llms.txt

Configure your `schema.prisma` file to use the `prisma-client` generator with `engineType: 'client'` for Rust-free operation. Ensure the output directory and module format are correctly set.

```prisma
// prisma/schema.prisma
generator client {
  provider     = "prisma-client"
  output       = "../src/generated/prisma"
  engineType   = "client"
  moduleFormat = "cjs"
}
datasource db {
  provider = "sqlite"
  url      = "file:dev.db"
}
```

--------------------------------

### Prisma CLI Configuration for Driver Adapter

Source: https://context7.com/notiz-dev/nestjs-prisma/llms.txt

Set up the `prisma.config.ts` file for the Prisma CLI, specifying the schema path and migration configuration. This file is used by Prisma commands like `migrate` and `generate`.

```typescript
// prisma.config.ts (Prisma CLI config)
import path from 'node:path';
import { defineConfig } from 'prisma/config';
export default defineConfig({
  schema: path.join('prisma', 'schema.prisma'),
  migrations: { path: './prisma/migrations', seed: 'tsx ./prisma/seed.ts' },
});
```

--------------------------------

### Add nestjs-prisma with schematics (non-interactive)

Source: https://context7.com/notiz-dev/nestjs-prisma/llms.txt

Configure nestjs-prisma non-interactively with specific options like PostgreSQL, Docker, and a Node version.

```bash
nest add nestjs-prisma --datasourceProvider postgresql --addDocker --dockerNodeImageVersion 20-alpine
```

--------------------------------

### PrismaConfigService Implementation

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/configuration.md

Implement `PrismaConfigService` by extending `PrismaOptionsFactory` to provide Prisma configuration options. This class can inject other services, like `ConfigService`, to dynamically set options.

```typescript
import {
  Injectable
} from '@nestjs/common';
import {
  PrismaOptionsFactory,
  PrismaServiceOptions
} from 'nestjs-prisma';

@Injectable()
export class PrismaConfigService implements PrismaOptionsFactory {
  constructor() {
    // TODO inject any other service here like the `ConfigService`
  }

  createPrismaOptions(): PrismaServiceOptions | Promise<PrismaServiceOptions> {
    return {
      prismaOptions: {
        log: ['info', 'query'],
      },
      explicitConnect: true,
    };
  }
}
```

--------------------------------

### Astro Project Structure

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/README.md

Illustrates the standard directory layout for an Astro project, including public assets, source files for components and pages, and the package.json.

```bash
├── public/
│   └── favicon.svg
├── src/
│   ├── components/
│   │   └── Card.astro
│   ├── layouts/
│   │   └── Layout.astro
│   └── pages/
│       └── index.astro
└── package.json
```

--------------------------------

### Use Shareable Query Logging Extension

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/query-logging-extension.md

Import and use the shareable `queryLoggingExtension` function when initializing the `PrismaClient` with `$extends`. This approach promotes code reusability for extensions.

```typescript
// prisma.extension.ts
import { Logger } from '@nestjs/common';
import { PrismaClient } from '@prisma/client';
import { queryLoggingExtension } from './query-logger.extension';

const logger = new Logger('PrismaClient');

export const extendedPrismaClient = new PrismaClient().$extends(
  queryLoggingExtension(logger),
);

export const ExtendedPrismaClient = typeof extendedPrismaClient;
```

--------------------------------

### Seed Database with Reused Prisma Client Instance

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/rust-free-and-driver-adapter.md

Seed your development database by importing and reusing the Prisma Client instance defined in `prisma.extension.ts`. This ensures consistency between your client and seeding logic.

```typescript
// prisma/seed.ts
// reuse the prisma client instance
import { prisma } from '../src/prisma.extension';

async function main() {
  console.log('Seeding database...');
  console.time('Seeding complete 🌱');

  // TODO seed development data

  console.timeEnd('Seeding complete 🌱');
}

main().catch((e) => console.log(e));
```

--------------------------------

### Extend Prisma Client with Read Replicas

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/prisma-client-extensions.md

Integrate the read-replicas extension into your Prisma Client. Remember to update the `url` to your actual read replica database URL.

```typescript
// prisma.extension.ts
import { PrismaClient } from '@prisma/client';
import { readReplicas } from '@prisma/extension-read-replicas';

export const extendedPrismaClient = new PrismaClient().$extends(
  // update url to your read replica url
  readReplicas({ url: 'postgresql://replica.example.com:5432/db' }),
);

export type ExtendedPrismaClient = typeof extendedPrismaClient;
```

--------------------------------

### Register Extended Prisma Client with useClass

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/prisma-client-extensions.md

Register the extended Prisma Client using `CustomPrismaModule.forRootAsync` with the `useClass` option. This involves creating a separate configuration service.

```typescript
import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';

import { CustomPrismaModule } from 'nestjs-prisma';
import { ExtendedPrismaConfigService } from './extended-prisma-config.service';

@Module({
  imports: [
    // ✅ use `forRootAsync` when using `PrismaClient().$extends({})`
    CustomPrismaModule.forRootAsync({
      name: 'PrismaService',
      useClass: ExtendedPrismaConfigService,
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}
```

--------------------------------

### Prisma CLI Configuration with prisma.config.ts

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/rust-free-and-driver-adapter.md

Optionally, configure the Prisma CLI for commands like `migrate` and `seed` by adding a `prisma.config.ts` file at the root level.

```typescript
import path from 'node:path';
import { defineConfig } from 'prisma/config';

export default defineConfig({
  schema: path.join('prisma', 'schema.prisma'),
  migrations: {
    path: './prisma/migrations',
    seed: 'tsx ./prisma/seed.ts',
  },
});
```

--------------------------------

### Subscribe to Prisma Query Events

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/prisma-logging.md

Use `$on()` via the `PrismaService` in `main.ts` to subscribe to all emitted query events and log them.

```typescript
// main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { PrismaService } from 'nestjs-prisma';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  // log query events
  const prismaService: PrismaService = app.get(PrismaService);
  prismaService.$on('query', (event) => {
    console.log(event);
  });

  await app.listen(process.env.PORT || 3000);
}
bootstrap();
```

--------------------------------

### Configure PrismaModule Asynchronously with useFactory

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/configuration.md

Configure `PrismaModule` asynchronously using `forRootAsync` with a `useFactory` function. This allows for dynamic configuration, such as setting logging levels and database connection URLs.

```typescript
import {
  Module
} from '@nestjs/common';
import {
  PrismaModule
} from 'nestjs-prisma';

@Module({
  imports: [
    PrismaModule.forRootAsync({
      isGlobal: true,
      useFactory: () => ({
        prismaOptions: {
          log: ['info', 'query'],
        },
        explicitConnect: false,
      }),
    }),
  ],
})
export class AppModule {}
```

--------------------------------

### Prisma Event-Based Logging Configuration

Source: https://context7.com/notiz-dev/nestjs-prisma/llms.txt

Configure Prisma to emit query events and subscribe to them in `main.ts` using `PrismaService.$on()`. This allows for custom logging of database queries and their durations.

```typescript
// src/app.module.ts
import { Module } from '@nestjs/common';
import { PrismaModule } from 'nestjs-prisma';

@Module({
  imports: [
    PrismaModule.forRoot({
      prismaServiceOptions: {
        prismaOptions: {
          log: [
            { emit: 'event', level: 'query' },
            { emit: 'stdout', level: 'warn' },
            { emit: 'stdout', level: 'error' },
          ],
        },
      },
    }),
  ],
})
export class AppModule {}

// src/main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { PrismaService } from 'nestjs-prisma';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  const prisma = app.get(PrismaService);
  prisma.$on('query', (e) => {
    console.log(`Query: ${e.query}`);
    console.log(`Duration: ${e.duration}ms`);
  });

  await app.listen(process.env.PORT ?? 3000);
}
bootstrap();
```

--------------------------------

### Configure PrismaModule Asynchronously with useClass

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/configuration.md

Configure `PrismaModule` asynchronously using `forRootAsync` with a `useClass` option. This approach utilizes a separate service class that implements `PrismaOptionsFactory` for configuration.

```typescript
import {
  Module
} from '@nestjs/common';
import {
  ConfigModule
} from '@nestjs/config';
import {
  PrismaModule
} from 'nestjs-prisma';

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true,
    }),
    PrismaModule.forRootAsync({
      isGlobal: true,
      useClass: PrismaConfigService,
    }),
  ],
})
export class AppModule {}
```

--------------------------------

### Register Multiple Custom Prisma Clients

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/custom-prisma-client-location.md

Register multiple Prisma Clients by repeating `CustomPrismaModule.forRoot` for each client, ensuring each has a unique name and its own `PrismaClient` instance.

```typescript
import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';

import { CustomPrismaModule } from 'nestjs-prisma';
import { PrismaClient as PrismaAuth } from '@notiz/prisma'; // 👈 update to your output directory
import { PrismaClient as PrismaCms } from '@notiz/prisma-cms'; // 👈 update to your output directory

@Module({
  imports: [
    CustomPrismaModule.forRoot({
      name: 'PrismaServiceAuth', // 👈 must be unique for each PrismaClient
      client: new PrismaAuth(),
    }),
    CustomPrismaModule.forRoot({
      name: 'PrismaServiceCms', // 👈 must be unique for each PrismaClient
      client: new PrismaCms(),
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}
```

--------------------------------

### Define Prisma Client Extension for Query Logging

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/query-logging-extension.md

Create a PrismaClient instance with a query logging extension. This extension intercepts all operations, logs their execution time, and returns the result. Adjust logging behavior as needed.

```typescript
// prisma.extension.ts
import { Logger } from '@nestjs/common';
import { PrismaClient } from '@prisma/client';

const logger = new Logger('PrismaClient');

export const extendedPrismaClient = new PrismaClient().$extends({
  query: {
    $allModels: {
      async $allOperations({ operation, model, args, query }) {
        const start = performance.now();
        const result = await query(args);
        const end = performance.now();
        const time = Math.ceil((end - start) * 100) / 100;
        // adjust logging behavior to your needs
        logger.log(`Prisma Query ${model}.${operation} took ${time}ms`);
        return result;
      },
    },
  },
});

export const ExtendedPrismaClient = typeof extendedPrismaClient;
```

--------------------------------

### Use Read Replicas and Primary Database with Extended Prisma Client

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/prisma-client-extensions.md

Demonstrates how to use the extended Prisma Client for read replica support within a NestJS application. It shows how read operations default to replicas, while write operations use the primary. The `$primary()` method is used to explicitly read from the primary database.

```typescript
import { Inject, Injectable } from '@nestjs/common';
import { CustomPrismaService } from 'nestjs-prisma';
import { type ExtendedPrismaClient } from './prisma.extension';

@Injectable()
export class AppService {
  constructor(
    // ✅ use `ExtendedPrismaClient` type for correct type-safety of your extended PrismaClient
    @Inject('PrismaService')
    private prismaService: CustomPrismaService<ExtendedPrismaClient>,
  ) {}

  users() {
    // uses database replica
    return this.prismaService.client.user.findMany();
  }

  user(id: string) {
    // bypasses database replica and uses primary database
    return this.prismaService.client
      .$primary()
      .user.findUnique({ where: { id } });
  }

  add(email: string) {
    // uses primary database
    return this.prismaService.client.user.create({
      data: {
        email,
      },
    });
  }
}
```

--------------------------------

### Configure Prisma Client Output Location

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/custom-prisma-client-location.md

Specify a custom output directory for the Prisma Client using the `output` property in the `generator` block.

```prisma
generator client {
  provider = "prisma-client-js"
  output = "../node_modules/@notiz/prisma"
}
```

--------------------------------

### Register Extended Prisma Client with useFactory

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/prisma-client-extensions.md

Register the extended Prisma Client using `CustomPrismaModule.forRootAsync` with the `useFactory` option. This is the recommended approach when using `PrismaClient().$extends({})`.

```typescript
import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';

import { CustomPrismaModule } from 'nestjs-prisma';
import { extendedPrismaClient } from './prisma.extension';

@Module({
  imports: [
    // ✅ use `forRootAsync` when using `PrismaClient().$extends({})`
    CustomPrismaModule.forRootAsync({
      name: 'PrismaService',
      useFactory: () => {
        return extendedPrismaClient;
      },
    }),
    // ❌ error: 'getOwnPropertyDescriptor' on proxy
    // CustomPrismaModule.forRoot({
    //   name: 'PrismaServiceAuth',
    //   client: new PrismaClient().$extends({}),
    // }),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}
```

--------------------------------

### Prisma Query Logging Extension

Source: https://context7.com/notiz-dev/nestjs-prisma/llms.txt

Implement a Prisma Client Extension to log the duration of all database operations. This extension requires a NestJS Logger instance and should be defined in a separate file.

```typescript
// src/query-logger.extension.ts
import { Logger } from '@nestjs/common';
import { Prisma } from '@prisma/client';

export const queryLoggingExtension = (logger: Logger) =>
  Prisma.defineExtension({
    name: 'prisma-extension-query-logger',
    query: {
      $allModels: {
        async $allOperations({ operation, model, args, query }) {
          const start = performance.now();
          const result = await query(args);
          const time = Math.ceil((performance.now() - start) * 100) / 100;
          logger.log(`Prisma Query ${model}.${operation} took ${time}ms`);
          return result;
        },
      },
    },
  });

// src/prisma.extension.ts
import { Logger } from '@nestjs/common';
import { PrismaClient } from '@prisma/client';
import { queryLoggingExtension } from './query-logger.extension';

const logger = new Logger('PrismaClient');
export const extendedPrismaClient = new PrismaClient().$extends(queryLoggingExtension(logger));
export type ExtendedPrismaClient = typeof extendedPrismaClient;

// Terminal output:
// [Nest] LOG [PrismaClient] Prisma Query User.findMany took 10ms
// [Nest] LOG [PrismaClient] Prisma Query User.create took 4ms
```

--------------------------------

### Extend Prisma Client with Pagination for All Models

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/prisma-client-extensions.md

Integrate the pagination extension into your Prisma Client to enable pagination for all models. Ensure you import PrismaClient and the pagination extension correctly.

```typescript
// prisma.extension.ts
import { PrismaClient } from '@prisma/client';
import pagination from 'prisma-extension-pagination';

// pagination for all models
export const extendedPrismaClient = new PrismaClient().$extends(pagination());

export type ExtendedPrismaClient = typeof extendedPrismaClient;
```

--------------------------------

### Extend Prisma Client with Custom Model Methods

Source: https://context7.com/notiz-dev/nestjs-prisma/llms.txt

Use `CustomPrismaModule.forRootAsync` with `useFactory` to provide an extended Prisma client. This is recommended to avoid proxy errors when using `$extends`.

```typescript
// src/prisma.extension.ts
import { PrismaClient } from '@prisma/client';

export const extendedPrismaClient = new PrismaClient().$extends({
  model: {
    user: {
      findByEmail: async (email: string) =>
        extendedPrismaClient.user.findFirstOrThrow({ where: { email } }),
    },
  },
});

export type ExtendedPrismaClient = typeof extendedPrismaClient;

// src/app.module.ts
import { Module } from '@nestjs/common';
import { CustomPrismaModule } from 'nestjs-prisma';
import { extendedPrismaClient } from './prisma.extension';

@Module({
  imports: [
    CustomPrismaModule.forRootAsync({
      name: 'PrismaService',
      useFactory: () => extendedPrismaClient,
    }),
  ],
})
export class AppModule {}

// src/app.service.ts
import {
  Inject,
  Injectable,
} from '@nestjs/common';
import { CustomPrismaService } from 'nestjs-prisma';
import { type ExtendedPrismaClient } from './prisma.extension';

@Injectable()
export class AppService {
  constructor(
    @Inject('PrismaService')
    private readonly prisma: CustomPrismaService<ExtendedPrismaClient>,
  ) {}

  users() { return this.prisma.client.user.findMany(); }
  userByEmail(email: string) { return this.prisma.client.user.findByEmail(email); }
}
```

--------------------------------

### Use Paginated Users with Extended Prisma Client

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/prisma-client-extensions.md

Demonstrates how to use the new `paginate` function provided by the pagination extension within a NestJS service. It shows how to inject the extended Prisma Client and retrieve paginated user data along with metadata.

```typescript
import { Inject, Injectable } from '@nestjs/common';
import { CustomPrismaService } from 'nestjs-prisma';
import { type ExtendedPrismaClient } from './prisma.extension';

@Injectable()
export class AppService {
  constructor(
    // ✅ use `ExtendedPrismaClient` from extension for correct type-safety
    @Inject('PrismaService')
    private prismaService: CustomPrismaService<ExtendedPrismaClient>,
  ) {}

  async usersPage() {
    // 🦾 use new `paginate` function
    const [users, meta] = await this.prismaService.client.user
      .paginate()
      .withPages({
        limit: 10,
        page: 1,
        includePageCount: true,
      });

    return {
      users,
      meta,
    };
  }
}
```

--------------------------------

### Create a Shareable Query Logging Extension Function

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/query-logging-extension.md

Define a reusable query logging extension function that accepts a Logger instance. This function can be imported and used with `$extends` to create shareable extensions.

```typescript
// query-logger.extension.ts
import { Logger } from '@nestjs/common';
import { Prisma } from '@prisma/client';

export const queryLoggingExtension = (logger: Logger) =>
  Prisma.defineExtension({
    name: 'prisma-extension-query-logger',
    query: {
      $allModels: {
        async $allOperations({ operation, model, args, query }) {
          const start = performance.now();
          const result = await query(args);
          const end = performance.now();
          const time = Math.ceil((end - start) * 100) / 100;
          logger.log(`Prisma Query ${model}.${operation} took ${time}ms`);
          return result;
        },
      },
    },
  });
```

--------------------------------

### Create a Custom Logging Middleware

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/prisma-middleware.md

Define a reusable logging middleware function that logs the duration of Prisma queries. This function should be exported and then imported into your AppModule.

```typescript
// src/logging-middleware.ts
import {
  Prisma
} from '@prisma/client';

export function loggingMiddleware(): Prisma.Middleware {
  return async (params, next) => {
    const before = Date.now();

    const result = await next(params);

    const after = Date.now();

    console.log(
      `Query ${params.model}.${params.action} took ${after - before}ms`,
    );

    return result;
  };
}
```

--------------------------------

### Configure Log Level via Environment Variables

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/logging-middleware.md

Dynamically set the log level using environment variables via `@nestjs/config`. Ensure `PRISMA_QUERY_LOG_LEVEL` is set in your `.env` file.

```typescript
import {
  Module
} from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { PrismaModule, loggingMiddleware, QueryInfo } from 'nestjs-prisma';

@Module({
  imports: [
    ConfigModule.forRoot({ isGlobal: true }),
    PrismaModule.forRootAsync({
      useFactory: (config: ConfigService) => {
        return {
          middlewares: [
            loggingMiddleware({
              logger: new Logger('PrismaMiddleware'),
              logLevel: config.get('PRISMA_QUERY_LOG_LEVEL'),
            }),
          ],
          prismaOptions: { log: ['warn', 'error'] },
        };
      },
      inject: [ConfigService],
    }),
  ],
})
export class AppModule {}
```

--------------------------------

### Configure Prisma Logging Level

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/prisma-logging.md

Specify the log level in `prismaOptions` of your `PrismaModule` to enable event-based logging.

```typescript
import {
  Module
} from '@nestjs/common';
import { PrismaModule } from 'nestjs-prisma';

@Module({
  imports: [
    PrismaModule.forRoot({
      prismaServiceOptions: {
        prismaOptions: {
          log: [
            {
              emit: 'event',
              level: 'query',
            },
          ],
        },
      },
    }),
  ],
})
export class AppModule {}
```

--------------------------------

### Add Prisma with Docker and Custom Node Version

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/schematics.md

This command adds Docker support to your NestJS Prisma project and specifies a custom Node.js image version for Docker. It uses PostgreSQL as the default database.

```bash
nest add nestjs-prisma --addDocker --dockerNodeImageVersion 14-alpine
```

--------------------------------

### Prisma Database Migration

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/examples/fastify/README.md

Perform a development database migration using Prisma. Ensure your prisma/schema.prisma file is updated before running this command.

```sh
npx prisma migrate dev
```

--------------------------------

### Import PrismaModule into AppModule

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/basic-usage.md

Add `PrismaModule` to the `imports` array in your `AppModule` to make `PrismaService` available for dependency injection.

```typescript
import { Module } from '@nestjs/common';
import { PrismaModule } from 'nestjs-prisma';

@Module({
  imports: [PrismaModule],
})
export class AppModule {}
```

--------------------------------

### Update Prisma Client Import Path

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/custom-prisma-client-location.md

After customizing the output location, update your import statements to reference the PrismaClient from the new path.

```diff
-import { PrismaClient } from '@prisma/client';
+import { PrismaClient } from '@notiz/prisma';
```

--------------------------------

### Import PrismaModule in AppModule

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/README.md

Add `PrismaModule` to the `imports` array in your `AppModule` to enable `PrismaService` injection.

```typescript
import {
  Module
} from '@nestjs/common';
import { PrismaModule } from 'nestjs-prisma';

@Module({
  imports: [PrismaModule.forRoot()],
})
export class AppModule {}
```

--------------------------------

### Extended Prisma Config Service

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/prisma-client-extensions.md

Implement `CustomPrismaClientFactory` to provide the extended Prisma Client. This service can be used to inject other dependencies like `ConfigService`.

```typescript
import { Injectable } from '@nestjs/common';
import { CustomPrismaClientFactory } from 'nestjs-prisma';
import { 
  type ExtendedPrismaClient,
  extendedPrismaClient,
} from './prisma.extension';

@Injectable()
export class ExtendedPrismaConfigService 
  implements CustomPrismaClientFactory<ExtendedPrismaClient>
{
  constructor() {
    // TODO inject any other service here like the `ConfigService`
  }

  createPrismaClient(): ExtendedPrismaClient {
    // you could pass options to your `PrismaClient` instance here
    return extendedPrismaClient;
  }
}
```

--------------------------------

### Import and Use Logging Middleware in PrismaModule

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/prisma-middleware.md

Integrate the custom logging middleware into your NestJS application by importing it and adding the result of calling the middleware function to the `middlewares` array in `PrismaModule.forRoot`.

```typescript
import {
  Module
} from '@nestjs/common';
import { PrismaModule } from 'nestjs-prisma';
import { loggingMiddleware } from './logging-middleware';

@Module({
  imports: [
    PrismaModule.forRoot({
      prismaServiceOptions: {
        middlewares: [loggingMiddleware()],
      },
    }),
  ],
})
export class AppModule {}
```

--------------------------------

### Import PrismaModule into AppModule

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/custom-prisma-service.md

Import the generated `PrismaModule` into your `AppModule` or any other module to gain access to the `PrismaService`. Ensure `nestjs-prisma` is not duplicated as a dependency to avoid import conflicts.

```typescript
import { Module } from '@nestjs/common';
import { PrismaModule } from './prisma/prisma.module';

@Module({
  imports: [PrismaModule],
})
export class AppModule {}
```

--------------------------------

### Use PrismaService via Dependency Injection

Source: https://github.com/notiz-dev/nestjs-prisma/blob/main/docs/src/content/docs/basic-usage.md

Inject `PrismaService` into your application classes (controllers, services, etc.) to interact with your database using the generated Prisma Client methods.

```typescript
import { Injectable } from '@nestjs/common';
import { PrismaService } from 'nestjs-prisma';

@Injectable()
export class AppService {
  constructor(private prisma: PrismaService) {}

  users() {
    return this.prisma.user.findMany();
  }

  user(userId: string) {
    return this.prisma.user.findUnique({
      where: { id: userId },
    });
  }
}
```

--------------------------------

### Configure Multiple Prisma Clients in NestJS

Source: https://context7.com/notiz-dev/nestjs-prisma/llms.txt

Use `CustomPrismaModule.forRoot` to configure multiple Prisma clients, each with a unique name, for use in your NestJS application. Inject them using their assigned names.

```typescript
// src/app.module.ts
import {
  Module,
} from '@nestjs/common';
import { CustomPrismaModule } from 'nestjs-prisma';
import { PrismaClient as PrismaAuth } from '@myorg/prisma-auth';
import { PrismaClient as PrismaCms } from '@myorg/prisma-cms';

@Module({
  imports: [
    CustomPrismaModule.forRoot({ name: 'PrismaServiceAuth', client: new PrismaAuth() }),
    CustomPrismaModule.forRoot({ name: 'PrismaServiceCms',  client: new PrismaCms() }),
  ],
})
export class AppModule {}

// src/app.service.ts
import {
  Inject,
  Injectable,
} from '@nestjs/common';
import { CustomPrismaService } from 'nestjs-prisma';
import { PrismaClient as PrismaAuth } from '@myorg/prisma-auth';
import { PrismaClient as PrismaCms } from '@myorg/prisma-cms';

@Injectable()
export class AppService {
  constructor(
    @Inject('PrismaServiceAuth') private readonly prismaAuth: CustomPrismaService<PrismaAuth>,
    @Inject('PrismaServiceCms')  private readonly prismaCms: CustomPrismaService<PrismaCms>,
  ) {}

  users() { return this.prismaAuth.client.user.findMany(); }
  posts() { return this.prismaCms.client.post.findMany(); }
}
```