Développement de bases de données avec Cursor : SQL, ORM et intégration Prisma

Le développement de bases de données est une partie essentielle du génie logiciel moderne, et les capacités IA de Cursor peuvent considérablement accélérer la conception de schémas, l'écriture de requêtes et l'intégration ORM. Ce guide couvre les workflows pratiques pour l'édition SQL, la configuration ORM, les migrations et l'optimisation de bases de données assistée par IA.

Prérequis

Avant de commencer :

• Cursor installé (dernière version recommandée)
• Serveur de base de données en cours d'exécution localement ou accessible à distance (PostgreSQL, MySQL ou SQLite)
• Node.js installé (pour les outils ORM)
• Compréhension de base de SQL et des concepts de bases de données

Configuration des projets de base de données dans Cursor

Structure du projet

Organisez vos fichiers liés à la base de données pour un contexte IA optimal :

project/
  prisma/
    schema.prisma       # Schéma Prisma
    migrations/         # Fichiers de migration
  src/
    db/
      connection.ts     # Connexion à la base de données
      queries/          # Requêtes SQL brutes
      repositories/     # Couche d'accès aux données
  scripts/
    seed.ts             # Remplissage de la base de données
  docker-compose.yml    # Configuration de la base de données locale

Ouvrir le projet dans Cursor

cd ~/my-database-project
cursor .

Édition SQL avec Cursor

Écrire des requêtes complexes

Cursor excelle dans la génération et l'optimisation de SQL. Utilisez des prompts en langage naturel :

Écris une requête PostgreSQL pour trouver les 5 meilleurs clients par valeur totale des commandes
durant les 30 derniers jours, incluant leur nom, email et total dépensé.

Cursor générera :

SELECT
  c.id,
  c.name,
  c.email,
  SUM(o.total_amount) AS total_spent
FROM customers c
JOIN orders o ON c.id = o.customer_id
WHERE o.created_at >= CURRENT_DATE - INTERVAL '30 days'
GROUP BY c.id, c.name, c.email
ORDER BY total_spent DESC
LIMIT 5;

Optimisation des requêtes

Collez une requête lente et demandez à Cursor de l'optimiser :

Cette requête prend plus de 3 secondes sur une table de 1M de lignes. Optimise-la :
[coller la requête]

Cursor suggérera des index, des réécritures de requêtes et expliquera les améliorations de performance.

Support des fichiers SQL

Cursor fournit la coloration syntaxique et IntelliSense pour les fichiers .sql :

1. Créez un fichier .sql
2. Cursor active automatiquement le mode SQL
3. Utilisez Ctrl+Space pour l'autocomplétion des noms de tables et de colonnes

Astuce pro

Stockez les modèles de requêtes réutilisables dans des fichiers .sql. Cursor les indexe et peut les référencer lors de la génération de nouvelles requêtes.

Intégration Prisma

Configuration de Prisma

Initialisez Prisma dans votre projet :

npm install prisma @prisma/client
npx prisma init

Conception de schéma avec l'IA

Décrivez votre modèle de données en langage naturel :

Conçois un schéma Prisma pour une application e-commerce avec :
- Utilisateurs (avec rôles : admin, customer, seller)
- Produits (avec catégories, suivi des stocks)
- Commandes (avec statut, détails d'expédition)
- Avis (liés aux produits et aux utilisateurs)

Cursor génère :

model User {
  id        Int      @id @default(autoincrement())
  email     String   @unique
  name      String
  role      Role     @default(CUSTOMER)
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt

  orders   Order[]
  reviews  Review[]
}

enum Role {
  ADMIN
  CUSTOMER
  SELLER
}

model Product {
  id          Int     @id @default(autoincrement())
  name        String
  description String?
  price       Decimal @db.Decimal(10, 2)
  inventory   Int     @default(0)
  categoryId  Int

  category  Category   @relation(fields: [categoryId], references: [id])
  reviews   Review[]
  orderItems OrderItem[]
}

model Category {
  id       Int       @id @default(autoincrement())
  name     String    @unique
  products Product[]
}

model Order {
  id        Int      @id @default(autoincrement())
  status    OrderStatus @default(PENDING)
  total     Decimal  @db.Decimal(10, 2)
  createdAt DateTime @default(now())
  userId    Int

  user       User        @relation(fields: [userId], references: [id])
  orderItems OrderItem[]
}

enum OrderStatus {
  PENDING
  PROCESSING
  SHIPPED
  DELIVERED
  CANCELLED
}

model OrderItem {
  id        Int     @id @default(autoincrement())
  quantity  Int
  unitPrice Decimal @db.Decimal(10, 2)
  orderId   Int
  productId Int

  order   Order   @relation(fields: [orderId], references: [id])
  product Product @relation(fields: [productId], references: [id])
}

model Review {
  id        Int      @id @default(autoincrement())
  rating    Int
  comment   String?
  createdAt DateTime @default(now())
  userId    Int
  productId Int

  user    User    @relation(fields: [userId], references: [id])
  product Product @relation(fields: [productId], references: [id])

  @@unique([userId, productId])
}

Génération des migrations

Après les modifications de schéma, générez et appliquez les migrations :

npx prisma migrate dev --name add_user_roles

Utilisez Cursor pour réviser les fichiers de migration avant de les appliquer :

Révise ce fichier de migration pour les pertes de données potentielles ou les problèmes :
[coller le contenu de migration.sql]

Requêtes Prisma Client

Générez des requêtes typées avec l'assistance IA :

Écris une requête Prisma pour obtenir toutes les commandes d'un utilisateur incluant les détails des produits

const userOrders = await prisma.order.findMany({
  where: { userId: 1 },
  include: {
    orderItems: {
      include: {
        product: {
          select: {
            name: true,
            price: true,
          },
        },
      },
    },
  },
  orderBy: {
    createdAt: 'desc',
  },
});

Workflows TypeORM et Sequelize

Configuration TypeORM

// src/db/data-source.ts
import { DataSource } from 'typeorm';
import { User } from './entities/User';
import { Order } from './entities/Order';

export const AppDataSource = new DataSource({
  type: 'postgres',
  host: 'localhost',
  port: 5432,
  username: 'user',
  password: 'password',
  database: 'myapp',
  synchronize: false,
  logging: true,
  entities: [User, Order],
  migrations: ['src/migrations/*.ts'],
});

Modèles Sequelize

// src/models/User.js
const { DataTypes } = require('sequelize');

module.exports = (sequelize) => {
  const User = sequelize.define('User', {
    id: {
      type: DataTypes.INTEGER,
      primaryKey: true,
      autoIncrement: true,
    },
    email: {
      type: DataTypes.STRING,
      allowNull: false,
      unique: true,
      validate: {
        isEmail: true,
      },
    },
    name: {
      type: DataTypes.STRING,
      allowNull: false,
    },
  }, {
    tableName: 'users',
    timestamps: true,
  });

  return User;
};

Visualisation du schéma de base de données

Utilisation de Prisma ERD

Générez des diagrammes entité-relation :

npx prisma generate --generator erd

Ou demandez à Cursor de créer un schéma visuel :

Crée un diagramme ERD Mermaid pour le schéma Prisma de ce projet

Optimisation de requêtes assistée par IA

Analyse des performances des requêtes

Partagez votre requête et le plan d'exécution :

Cette requête effectue un scan séquentiel. Comment puis-je ajouter des index pour l'optimiser ?

EXPLAIN ANALYZE SELECT * FROM orders WHERE status = 'pending' AND created_at > '2024-01-01';

Cursor suggérera :

CREATE INDEX idx_orders_status_created_at ON orders(status, created_at);

Revue de la conception de base de données

Demandez à Cursor de réviser votre schéma selon les bonnes pratiques :

Révise ce schéma de base de données pour :
1. Les problèmes de normalisation
2. Les index manquants sur les clés étrangères
3. Les optimisations de types de données
4. Les problèmes de concurrence potentiels

Docker Compose pour le développement local

version: '3.8'
services:
  postgres:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: dev
      POSTGRES_PASSWORD: devpass
      POSTGRES_DB: myapp
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

  mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: rootpass
      MYSQL_DATABASE: myapp
      MYSQL_USER: dev
      MYSQL_PASSWORD: devpass
    ports:
      - "3306:3306"
    volumes:
      - mysql_data:/var/lib/mysql

volumes:
  postgres_data:
  mysql_data:

Tâches courantes de bases de données

Tâche	Exemple de prompt Cursor
Créer une migration	"Génère une migration pour ajouter une colonne de suppression logique à la table users"
Données de test	"Écris un script de seed pour remplir la base de données avec 100 utilisateurs de test"
Requête de sauvegarde	"Écris une commande pg_dump pour sauvegarder uniquement les tables users et orders"
Pool de connexions	"Configure le pool de connexions pour une app Node.js avec 100 utilisateurs simultanés"
Journal d'audit	"Ajoute une table de journal d'audit qui trace tous les changements sur la table orders"

Débogage des problèmes de base de données

Problèmes de connexion

Mon client Prisma ne peut pas se connecter à PostgreSQL. Voici ma chaîne de connexion et l'erreur :
[coller l'erreur]

Échecs de migration

Lorsqu'une migration échoue :

1. Vérifiez le statut de la migration :

npx prisma migrate status

2. Demandez à Cursor d'analyser l'échec et de suggérer des corrections

3. Résolvez les conflits et marquez comme appliqué si nécessaire :

npx prisma migrate resolve --applied migration_name

Bonnes pratiques

Sécurité

• Ne jamais commettre les identifiants de base de données dans le contrôle de version
• Utiliser des variables d'environnement pour les chaînes de connexion
• Activer SSL pour les connexions de production
• Utiliser des requêtes paramétrées pour prévenir l'injection SQL

Performance

• Ajouter des index sur les colonnes fréquemment interrogées
• Utiliser le pool de connexions en production
• Implémenter la mise en cache des résultats de requêtes pour les charges de travail en lecture intensive
• Surveiller les logs de requêtes lentes

Contrôle de version

# Database
*.db
*.sqlite
*.sqlite3
.env
.env.local
prisma/migrations/migration_lock.toml

Référence rapide

Action	Commande
Générer le client Prisma	npx prisma generate
Exécuter les migrations	npx prisma migrate dev
Réinitialiser la base de données	npx prisma migrate reset
Ouvrir Prisma Studio	npx prisma studio
Remplir la base de données	npx prisma db seed
Formater le schéma	npx prisma format

Ressources connexes

• Guide de développement Docker avec Cursor
• Guide de développement d'API avec Cursor
• Guide de test avec Cursor

Dernière mise à jour : Juillet 2025