Prisma ORM : du début à la fin du projet utilisant JS

Qu’est-ce que Prisma ?

Prisma : ORM de nouvelle génération pour Node.js et TypeScript

ORM : Le mappage de relations d'objets est un moyen de communiquer avec des bases de données à l'aide de langages POO, sans avoir besoin d'écrire des requêtes complexes.

• Prisma vise à rendre les bases de données faciles pour les développeurs.
• Il offre une sécurité de type, une API intuitive et augmente la productivité des développeurs.
• Se concentre sur l'expérience du développeur.

Composants clés

• Prisma Schema : La source unique de vérité pour votre schéma de base de données. Définit les modèles et leurs relations.
• Prisma Client : Générateur de requêtes généré automatiquement et adapté à votre schéma. Fournit un accès sécurisé à votre base de données.
• Prisma Migrate : Outil de gestion des migrations de schémas de bases de données.

---

Pourquoi Prisma ?

1. Simplification des interactions avec les bases de données : Prisma ORM fournit des requêtes intuitives et une migration de schéma.
2. Amélioration de la qualité du code : Prisma ORM génère des requêtes de type sécurisé et s'intègre aux IDE populaires.
3. Prise en charge de plusieurs bases de données : Prisma ORM facilite l'adaptation et le développement des applications. (par exemple, MongoDB, MySQL, MariaDB, PostgreSQL, Microsoft SQL, etc.)
4. Atténuation des problèmes des ORM traditionnels : Prisma ORM résout des problèmes tels que les instances de modèle gonflées et les requêtes imprévisibles.

Configuration du projet

1. Configuration du projet

Créer un nouveau répertoire de projet

mkdir prisma-example
cd prisma-example

Initialiser un projet Node.js

npm init -y

Installer la CLI Prisma

npm install prisma dotenv express --save-dev

Installez le client Prisma

npm install @prisma/client --save-dev

Cela installe le client Prisma pour votre base de données.

2. Initialiser Prisma

npx prisma init

Cela crée un répertoire prisma contenant :

• schema.prisma : Votre fichier de schéma Prisma.
• .env : Pour la chaîne de connexion à votre base de données.

3. Configurez la connexion à la base de données

Choisissez une base de données

La vidéo utilise probablement PostgreSQL, mais vous pouvez l'adapter à MySQL, SQLite ou autres. Pour cet exemple, nous utiliserons PostgreSQL.

Définissez la DATABASE_URL

Dans votre fichier .env, ajoutez la chaîne de connexion. Exemple pour PostgreSQL :

DATABASE_URL="postgresql://your_user:your_password@localhost:5432/your_database"

Remplacez your_user, your_password et your_database par vos informations d'identification réelles. Si vous ne disposez pas d'un serveur PostgreSQL local, vous devrez en installer et en configurer un.

4. Définir les modèles de données (schema.prisma)

Remplacez le contenu de prisma/schema.prisma par ce qui suit :

mkdir prisma-example
cd prisma-example

5. Générer le client Prisma

npm init -y

Cela génère le client Prisma de type sécurisé dans node_modules/@prisma/client.

6. Créer une migration

npm install prisma dotenv express --save-dev

Cela crée un nouveau fichier de migration dans le répertoire prisma/migrations et l'applique à votre base de données, créant ainsi les tables. Le --name init donne à la migration un nom descriptif.

7. Création d'un fichier séparé pour la configuration de Prisma

Créez un fichier db.config.js dans le répertoire racine et ajoutez le code suivant :

npm install @prisma/client --save-dev

Cela créera une nouvelle instance de PrismaClient et l'exportera afin qu'elle puisse être utilisée dans d'autres fichiers. L'option log : ['query'] enregistrera toutes les requêtes sur la console.

8. Création d'une API Express de base pour comprendre le fonctionnement de Prisma

1. Contrôleur

Créez un fichier contrôleurs.js à la racine du projet. Voici le code des opérations CRUD dans le fichier controllers.js :

npx prisma init

2. Itinéraires

Créez un fichier routes.js à la racine du projet. Voici le code des opérations CRUD dans le fichier routes.js :

DATABASE_URL="postgresql://your_user:your_password@localhost:5432/your_database"

3. Serveur

Créez un fichier server.js à la racine du projet. Voici le code des opérations CRUD dans le fichier server.js :

generator client {
    provider = "prisma-client-js"
}

datasource db {
    provider = "postgresql" // Or "mysql", "sqlite", etc.
    url      = env("DATABASE_URL")
}

model Post {
    id        String   @id @default(uuid())
    title     String
    content   String?
    createdAt DateTime @default(now())
    author    User     @relation(fields: [user_id], references: [id])
    user_id   Int
}

model User {
    id    Int     @id @default(autoincrement())
    email String  @unique
    name  String?
    posts Post[]
}

9. Exécutez le script

npx prisma generate

Cela exécutera le script, créera un utilisateur et une publication dans votre base de données, puis mettra à jour l'utilisateur et supprimera la publication.

Vous pouvez utiliser Postman pour tester l'API avec les itinéraires suivants :

• POST : http://localhost:5000/api/users
• OBTENIR : http://localhost:5000/api/users
• OBTENIR : http://localhost:5000/api/users/1
• PUT : http://localhost:5000/api/users/1
• SUPPRIMER : http://localhost:5000/api/users/1

Définissez le corps dans Postman pour la requête POST en JSON avec les données suivantes :

npx prisma migrate dev --name init

Points clés à considérer pour la syntaxe Prisma

• findUnique/findFirst - pour obtenir un seul enregistrement, ne renvoie pas de tableau.
• findMany - pour obtenir plusieurs enregistrements, renvoie un tableau.
• include - pour inclure les données associées.
• select - pour sélectionner des champs spécifiques.
• Vous ne pouvez utiliser qu'un seul des attributs, soit select, soit include.

Exemples de syntaxe Prisma

import { PrismaClient } from "@prisma/client";

const prisma = new PrismaClient({
    log: ["query"],
});

export default prisma;

En savoir plus sur les agrégations, le filtrage, le classement et les relations Prisma

1. Fonctions d'agrégation dans Prisma

Prisma fournit plusieurs fonctions d'agrégation qui vous permettent d'effectuer des calculs sur des ensembles de données directement dans vos requêtes de base de données. Ces fonctions sont utiles pour résumer les données et obtenir des informations sans avoir à récupérer de grandes quantités de données vers votre application.

Fonctions d'agrégation communes

• _count : Compte le nombre d'enregistrements qui correspondent aux critères donnés.
• _avg : Calcule la moyenne d'un champ numérique.
• _sum : Calcule la somme d'un champ numérique.
• _min : Trouve la valeur minimale d'un champ.
• _max : Trouve la valeur maximale d'un champ.

Exemples d'agrégation

Supposons que nous ayons le modèle de produit suivant :

mkdir prisma-example
cd prisma-example

Compter le nombre de produits dans chaque catégorie

npm init -y

Calculer le prix moyen de tous les produits

npm install prisma dotenv express --save-dev

Trouver le prix minimum et maximum des produits dans une catégorie spécifique

npm install @prisma/client --save-dev

Somme des prix des produits créés au cours de la semaine dernière

npx prisma init

2. Filtrage dans Prisma

Prisma propose un riche ensemble d'options de filtrage qui vous permettent d'interroger précisément votre base de données. Voici un aperçu complet avec des exemples :

Filtrage de base

• égal (par défaut) : Vérifie l'égalité exacte.
  

  DATABASE_URL="postgresql://your_user:your_password@localhost:5432/your_database"
  

• non : annule une condition.
  

  generator client {
      provider = "prisma-client-js"
  }
  
  datasource db {
      provider = "postgresql" // Or "mysql", "sqlite", etc.
      url      = env("DATABASE_URL")
  }
  
  model Post {
      id        String   @id @default(uuid())
      title     String
      content   String?
      createdAt DateTime @default(now())
      author    User     @relation(fields: [user_id], references: [id])
      user_id   Int
  }
  
  model User {
      id    Int     @id @default(autoincrement())
      email String  @unique
      name  String?
      posts Post[]
  }
  

Opérateurs de comparaison

• gt (Supérieur à), gte (Supérieur ou égal à), lt (Inférieur à), lte (Inférieur ou égal à) : Utilisé pour les comparaisons numériques et de date/heure.
  

  npx prisma generate
  

Filtres de chaînes

• contient : Vérifie si une chaîne contient une sous-chaîne.
  

  npx prisma migrate dev --name init
  

• startsWith : Vérifie si une chaîne commence par un préfixe.
  

  import { PrismaClient } from "@prisma/client";
  
  const prisma = new PrismaClient({
      log: ["query"],
  });
  
  export default prisma;
  

• endsWith : Vérifie si une chaîne se termine par un suffixe.
  

  import prisma from "./db.config.js";
  
  // create user
  export const createUser = async (req, res) => {
      const { name, email } = req.body;
  
      const existing_user = await prisma.user.findUnique({
          where: {
              email,
          },
      });
  
      if (existing_user) {
          return res.status(400).json({ message: "User already exists" });
      }
  
      const user = await prisma.user.create({
          data: {
              email,
              name,
          },
      });
  
      return res.status(201).json(user);
  };
  
  // create post
  export const createPost = async (req, res) => {
      const { title, content, user_id } = req.body;
  
      const post = await prisma.post.create({
          data: {
              title,
              content,
              user_id,
          },
      });
  
      return res.status(201).json(post);
  };
  
  // get all users
  export const getUsers = async (req, res) => {
      const users = await prisma.user.findMany({
          include: {
              posts: true,
          },
      });
  
      return res.status(200).json(users);
  };
  
  // read specific user by id
  export const getUserById = async (req, res) => {
      const { id } = req.params;
  
      const user = await prisma.user.findUnique({
          where: {
              id: parseInt(id),
          },
          include: {
              posts: true,
          },
      });
  
      if (!user) {
          return res.status(404).json({ message: "User not found" });
      }
  
      return res.status(200).json(user);
  };
  
  // update user
  export const updateUser = async (req, res) => {
      const { id } = req.params;
      const { name, email } = req.body;
  
      const user = await prisma.user.update({
          where: {
              id: parseInt(id),
          },
          data: {
              name,
              email,
          },
      });
  
      return res.status(200).json(user);
  };
  
  // delete user
  export const deleteUser = async (req, res) => {
      const { id } = req.params;
  
      const user = await prisma.user.delete({
          where: {
              id: parseInt(id),
          },
      });
  
      return res.status(200).json(user);
  };
  
  // create similar for post
  

• mode : insensible : Effectue des recherches insensibles à la casse.
  

  import express from "express";
  import {
      createUser,
      createPost,
      getUsers,
      getUserById,
      updateUser,
      deleteUser,
  } from "./controllers.js";
  
  const router = express.Router();
  
  router.post("/users", createUser);
  router.get("/users", getUsers);
  router.get("/users/:id", getUserById);
  router.put("/users/:id", updateUser);
  router.delete("/users/:id", deleteUser);
  // create similar for post
  router.post("/posts", createPost);
  // router.get('/posts', getPosts);
  // router.get('/posts/:id', getPostById);
  // router.put('/posts/:id', updatePost);
  // router.delete('/posts/:id', deletePost);
  
  export default router;
  

Filtres de liste

• in : Vérifie si une valeur est présente dans une liste.
  

  import express from "express";
  import dotenv from "dotenv";
  import router from "./routes.js";
  
  dotenv.config();
  
  const app = express();
  
  app.use(express.json());
  app.use("/api", router);
  
  const PORT = process.env.PORT || 5000;
  
  app.listen(PORT, () => {
      console.log(`Server running on port ${PORT}`);
  });
  

• notIn : Vérifie si une valeur n'est pas présente dans une liste.
  

  node index.js
  

Opérateurs logiques

• AND : Combine plusieurs conditions avec un ET logique.
  

  {
      "name": "John Doe",
      "email": "sample@example.com"
  }
  

• OU : Combine plusieurs conditions avec un OU logique.
  

  // get all posts of a user with id
  const user = await prisma.user.findUnique({
      where: {
          id: parseInt(id),
      },
      include: {
          posts: true,
      },
  });
  
  // select specific fields of user with post details
  const user = await prisma.user.findUnique({
      where: {
          id: parseInt(id),
      },
      select: {
          name: true,
          posts: {
              select: {
                  title: true,
                  content: true,
              },
          },
      },
  });
  
  // get all users name with their posts count (Aggregation)
  const req_data = await prisma.user.findMany({
      select: {
          id: true,
          name: true,
          _count: {
              select: {
                  post: true,
              },
          },
      },
  });
  

• NON : Annule un groupe de conditions.
  

  model Product {
      id        Int      @id @default(autoincrement())
      name      String
      price     Float
      category  String
      createdAt DateTime @default(now())
  }
  

Filtres imbriqués (filtrage sur les relations)

Vous pouvez filtrer en fonction des modèles associés.

mkdir prisma-example
cd prisma-example

Filtrage sur les relations facultatives

npm init -y

Combinaison de filtres

Vous pouvez combiner ces opérateurs pour une logique de filtrage complexe.

npm install prisma dotenv express --save-dev

Ces exemples couvrent les scénarios de filtrage les plus courants dans Prisma. En combinant ces opérateurs et filtres imbriqués, vous pouvez créer des requêtes très précises pour récupérer les données exactes dont vous avez besoin. N'oubliez pas de consulter la documentation officielle de Prisma pour les informations les plus récentes et les plus détaillées.

Registres de commande à Prisma

L'option orderBy de Prisma vous permet de trier les résultats de vos requêtes. Voici quelques exemples démontrant son utilisation :

Commande de base

• Ordre croissant (par défaut) :
  

  npm install @prisma/client --save-dev
  

• Ordre décroissant :
  

  npx prisma init
  

Tri par plusieurs champs

Vous pouvez spécifier plusieurs champs à trier, avec des directions différentes pour chacun. Prisma triera d'abord par le premier champ, puis par le deuxième champ au sein de groupes de valeurs identiques dans le premier champ, et ainsi de suite.

DATABASE_URL="postgresql://your_user:your_password@localhost:5432/your_database"

Dans cet exemple, les messages seront principalement triés par nom d'auteur par ordre croissant. Si plusieurs articles ont le même auteur, ils seront alors triés par leurs titres par ordre décroissant.

Tri par champs imbriqués (relations)

Comme le montre l'exemple précédent, vous pouvez trier par champs sur les modèles associés.

generator client {
    provider = "prisma-client-js"
}

datasource db {
    provider = "postgresql" // Or "mysql", "sqlite", etc.
    url      = env("DATABASE_URL")
}

model Post {
    id        String   @id @default(uuid())
    title     String
    content   String?
    createdAt DateTime @default(now())
    author    User     @relation(fields: [user_id], references: [id])
    user_id   Int
}

model User {
    id    Int     @id @default(autoincrement())
    email String  @unique
    name  String?
    posts Post[]
}

Cela classera les articles en fonction de l'adresse e-mail de leurs auteurs.

Trier par champs de date/heure

Vous pouvez également trier par champs de date et d'heure.

npx prisma generate

Tri par un champ différent du champ de filtrage

Vous pouvez filtrer par un champ et commander par un autre. Par exemple, vous souhaiterez peut-être rechercher tous les utilisateurs dont le nom contient « test », mais les classer par adresse e-mail :

npx prisma migrate dev --name init

Utilisation de l'option Nulls

Vous pouvez contrôler la manière dont les valeurs nulles sont traitées lors du tri. L'option nulls peut être définie sur premier ou dernier.

import { PrismaClient } from "@prisma/client";

const prisma = new PrismaClient({
    log: ["query"],
});

export default prisma;

Par défaut, les valeurs nulles sont placées en dernier lors du tri par ordre croissant et en premier lors du tri par ordre décroissant. L'option nulls vous permet de remplacer ce comportement par défaut.

Fonctions de relation dans Prisma

Prisma excelle dans la gestion élégante des relations avec les bases de données. Voici les aspects clés :

• Définition des relations dans le schéma : Vous définissez les relations entre les modèles directement dans votre fichier schema.prisma à l'aide de l'attribut @relation.

• Types de relations : Prisma prend en charge :

  • One-to-One : Un enregistrement du modèle A est lié à exactement un enregistrement du modèle B.
  • Un-à-Many : Un enregistrement dans le modèle A est lié à plusieurs enregistrements dans le modèle B.
  • Plusieurs à plusieurs : Plusieurs enregistrements du modèle A sont liés à plusieurs enregistrements du modèle B (nécessite une table de jointure).

Exemples de relations

Utilisons les modèles User et Post des exemples précédents :

mkdir prisma-example
cd prisma-example

J'espère que cela vous aidera à mieux comprendre l'ORM Prisma.
N'hésitez pas à donner votre avis et vos suggestions.

Merci d'avoir lu ! ?

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!