Référence API Prisma Client

Référence API complète pour Prisma Client. Cette compétence fournit des conseils sur les requêtes de modèles, le filtrage, les relations et les méthodes client pour les projets Prisma actuels.

Quand l'utiliser

Consultez cette compétence quand :

Vous écrivez des requêtes de base de données avec Prisma Client
Vous effectuez des opérations CRUD (créer, lire, mettre à jour, supprimer)
Vous filtrez et triez les données
Vous travaillez avec des relations
Vous utilisez des transactions
Vous configurez les options client

Catégories de règles par priorité

Priorité	Catégorie	Impact	Préfixe
1	Construction du client	HIGH	`constructor`
2	Requêtes de modèles	CRITICAL	`model-queries`
3	Forme de requête	HIGH	`query-options`
4	Filtrage	HIGH	`filters`
5	Relations	HIGH	`relations`
6	Transactions	CRITICAL	`transactions`
7	SQL brut	CRITICAL	`raw-queries`
8	Méthodes client	MEDIUM	`client-methods`

Référence rapide

constructor - configuration de PrismaClient, câblage d'adaptateurs, journalisation et plugins SQL commenter
model-queries - opérations CRUD et opérations en masse
query-options - select, include, omit, tri, pagination
filters - opérateurs de filtrage scalaires et logiques
relations - lectures de relations et écritures imbriquées
transactions - modèles de transactions en tableau et interactives
raw-queries - sécurité de $queryRaw et $executeRaw
client-methods - méthodes de cycle de vie, extensions et modèles satisfies pour prisma-client

Instanciation du client

import { PrismaClient } from '../generated/client'
import { PrismaPg } from '@prisma/adapter-pg'

const adapter = new PrismaPg({
  connectionString: process.env.DATABASE_URL
})

const prisma = new PrismaClient({ adapter })

Méthodes de requête de modèles

Méthode	Description
`findUnique()`	Trouver un enregistrement par champ unique
`findUniqueOrThrow()`	Trouver un ou lever une erreur
`findFirst()`	Trouver le premier enregistrement correspondant
`findFirstOrThrow()`	Trouver le premier ou lever une erreur
`findMany()`	Trouver plusieurs enregistrements
`create()`	Créer un nouvel enregistrement
`createMany()`	Créer plusieurs enregistrements
`createManyAndReturn()`	Créer plusieurs et les retourner
`update()`	Mettre à jour un enregistrement
`updateMany()`	Mettre à jour plusieurs enregistrements
`updateManyAndReturn()`	Mettre à jour plusieurs et les retourner
`upsert()`	Mettre à jour ou créer un enregistrement
`delete()`	Supprimer un enregistrement
`deleteMany()`	Supprimer plusieurs enregistrements
`count()`	Compter les enregistrements correspondants
`aggregate()`	Agréger des valeurs (somme, moyenne, etc.)
`groupBy()`	Grouper et agréger

Options de requête

Option	Description
`where`	Conditions de filtrage
`select`	Champs à inclure
`include`	Relations à charger
`omit`	Champs à exclure
`orderBy`	Ordre de tri
`take`	Limiter les résultats
`skip`	Ignorer les résultats (pagination)
`cursor`	Pagination basée sur le curseur
`distinct`	Valeurs uniques uniquement

Méthodes client

Méthode	Description
`$connect()`	Se connecter explicitement à la base de données
`$disconnect()`	Se déconnecter de la base de données
`$transaction()`	Exécuter une transaction
`$queryRaw()`	Exécuter une requête SQL brute
`$executeRaw()`	Exécuter une commande SQL brute
`$on()`	S'abonner à des événements
`$extends()`	Ajouter des extensions

Exemples rapides

Trouver des enregistrements

// Trouver par champ unique
const user = await prisma.user.findUnique({
  where: { email: 'alice@prisma.io' }
})

// Trouver avec filtre
const users = await prisma.user.findMany({
  where: { role: 'ADMIN' },
  orderBy: { createdAt: 'desc' },
  take: 10
})

Créer des enregistrements

const user = await prisma.user.create({
  data: {
    email: 'alice@prisma.io',
    name: 'Alice',
    posts: {
      create: { title: 'Hello World' }
    }
  },
  include: { posts: true }
})

Mettre à jour des enregistrements

const user = await prisma.user.update({
  where: { id: 1 },
  data: { name: 'Alice Smith' }
})

Supprimer des enregistrements

await prisma.user.delete({
  where: { id: 1 }
})

Transactions

const [user, post] = await prisma.$transaction([
  prisma.user.create({ data: { email: 'alice@prisma.io' } }),
  prisma.post.create({ data: { title: 'Hello', authorId: 1 } })
])

Fichiers de règles

Documentation API détaillée :

references/constructor.md        - Options du constructeur PrismaClient
references/model-queries.md      - Opérations CRUD
references/query-options.md      - select, include, omit, where, orderBy
references/filters.md            - Conditions de filtrage et opérateurs
references/relations.md          - Requêtes de relations et opérations imbriquées
references/transactions.md       - API des transactions
references/raw-queries.md        - $queryRaw, $executeRaw
references/client-methods.md     - $connect, $disconnect, $on, $extends

Opérateurs de filtrage

Opérateur	Description
`equals`	Correspondance exacte
`not`	Non égal
`in`	Dans un tableau
`notIn`	Pas dans un tableau
`lt`, `lte`	Inférieur à
`gt`, `gte`	Supérieur à
`contains`	Contient (chaîne)
`startsWith`	Commence par
`endsWith`	Se termine par
`mode`	Sensibilité à la casse

Filtres de relations

Opérateur	Description
`some`	Au moins un enregistrement lié correspond
`every`	Tous les enregistrements liés correspondent
`none`	Aucun enregistrement lié ne correspond
`is`	L'enregistrement lié correspond (1 à 1)
`isNot`	L'enregistrement lié ne correspond pas

Ressources

Comment l'utiliser

Choisissez la catégorie dans le tableau ci-dessus, puis ouvrez le fichier de référence correspondant pour les détails d'implémentation et les exemples.

prisma-client-api