@e-xiste/drizzle-cli NPM

Drizzle CLI

Présentation du projet

Drizzle CLI est un outil en ligne de commande conçu pour simplifier la création et la gestion des schémas de base de données avec Drizzle ORM. Inspiré par la commande make:entity du MakerBundle de Symfony, cet outil permet aux développeurs de générer et de modifier des tables de base de données de manière interactive et intuitive.

Note importante : Actuellement, seul PostgreSQL est pris en charge et un fichier schema.ts unique est utilisé. Seul TypeScript est supporté pour la génération des schémas.

Fonctionnalités

Création de tables : Générez rapidement de nouvelles tables avec leurs colonnes
Mise à jour de tables : Modifiez facilement les tables existantes
Gestion des relations : Configurez les relations entre tables (one-to-one, one-to-many, many-to-one, many-to-many)
Interface interactive : Définissez vos schémas à travers une série de questions et réponses
Génération automatique de code : Production automatique du fichier de schéma Drizzle
Support TypeScript : Génération du fichier de schéma en TypeScript
Schémas d'exemple : Génération de schémas complets pour des cas d'utilisation courants (blog, e-commerce, etc.)
Types de colonnes : Support pour tous les types de colonnes PostgreSQL courants (varchar, integer, boolean, decimal, timestamp, etc.)
Options de colonnes : Configuration des options de colonnes comme nullable, unique, valeurs par défaut, etc.
Gestion des erreurs : Gestion robuste des erreurs avec des messages clairs
Documentation : Documentation complète avec exemples
Scripts d'exemple : Scripts prêts à l'emploi pour générer et mettre à jour des schémas
Guide d'utilisation détaillé : Instructions étape par étape pour les cas d'utilisation courants

Installation

Installation globale

Pour installer le package globalement et l'utiliser depuis n'importe quel projet :

npm install -g @e-xiste/drizzle-cli

Avec cette installation, vous pouvez exécuter les commandes directement :

drizzle-cli make:table

Installation locale dans un projet

Pour installer le package comme dépendance de développement dans un projet spécifique :

npm install --save-dev @e-xiste/drizzle-cli

Guide de démarrage rapide

Voici les étapes complètes pour commencer à utiliser drizzle-cli dans votre projet :

Initialiser le projet :

# Avec une installation globale
drizzle-cli init
# OU avec une installation locale
npx drizzle-cli init

Créer votre première table :

# Avec une installation globale
drizzle-cli make:table
# OU avec une installation locale
npx drizzle-cli make:table

Initialisation du projet

Le fichier de configuration est drizzle.config.ts à la racine de votre projet.

Si vous souhaitez écraser un fichier de configuration existant, utilisez l'option --force :

drizzle-cli init --force

Structure du fichier de configuration

Le fichier drizzle.config.ts généré ressemblera à ceci :

/**
 * Configuration pour drizzle-cli
 */
export default {
  // TypeScript est utilisé pour la génération du schéma
  
  // Chemin vers le fichier de schéma
  schemaFile: './schema.ts',
  
  // Tous les fichiers sont générés en TypeScript
  fileExtension: '.ts',
};

Utilisation

Commandes disponibles

`init` - Initialiser un nouveau projet

drizzle-cli init [options]

Options :

-y, --yes : Accepter les valeurs par défaut sans poser de questions
-f, --force : Écraser le fichier de configuration existant

Exemple :

drizzle-cli init --force

`config` - Afficher ou modifier la configuration

drizzle-cli config [options]

Options :

-g, --get <key> : Afficher la valeur d'une clé de configuration spécifique
-s, --set <key>=<value> : Définir la valeur d'une clé de configuration
-l, --list : Lister toutes les configurations

Exemples :

# Lister toutes les valeurs de configuration
drizzle-cli config --list

# Obtenir une valeur de configuration spécifique
drizzle-cli config --get schemaFile

# Définir une valeur de configuration
drizzle-cli config --set schemaFile=./src/db/schema.ts

`make:table` - Create or update a table

drizzle-cli make:table [options]

Options:

--name <name>: Specify the table name
--force: Overwrite the table if it already exists

Examples:

# Create a table interactively
drizzle-cli make:table

# Create a table with a specific name
drizzle-cli make:table --name users

# Force overwrite an existing table
drizzle-cli make:table --name users --force

Mode interactif

La commande make:table vous guidera à travers une série de questions pour définir votre table :

Nom de la table : Entrez le nom de votre table
Colonnes : Pour chaque colonne, on vous demandera :
- Nom de la colonne
- Type de colonne (varchar, integer, boolean, etc.)
- Options (nullable, unique, valeur par défaut, etc.)
Relations : Définir les relations avec d'autres tables

Exemple de workflow

# Initialiser le projet
drizzle-cli init

# Créer une table users
drizzle-cli make:table --name users

# Créer une table posts avec une relation vers users
drizzle-cli make:table --name posts

Documentation

Guide d'utilisation détaillé

Un guide d'utilisation complet est disponible dans le répertoire docs :

# Voir le guide d'utilisation détaillé
cat docs/guide-utilisation-detaille.md

Le guide couvre :

Installation et configuration
Création et mise à jour des tables
Gestion des relations
Exemples pour les schémas de blog et d'e-commerce
Best practices
Troubleshooting

Scripts d'exemple

Le répertoire examples/scripts contient des scripts prêts à l'emploi pour vous aider à démarrer :

generate-schema.js

Ce script génère des schémas complets pour différents types d'applications :

# Générer un schéma de blog
node examples/scripts/generate-schema.js --type=blog

# Générer un schéma d'e-commerce
node examples/scripts/generate-schema.js --type=ecommerce

update-schema.js

Ce script vous aide à mettre à jour des schémas existants en ajoutant de nouvelles colonnes ou tables :

# Créer une nouvelle table
node examples/scripts/update-schema.js --table=new_table

# Ajouter une colonne à une table existante
node examples/scripts/update-schema.js --table=existing_table --add-column=column_name:column_type

Pour plus de détails, consultez le README dans le répertoire examples/scripts.

Utilisation avec une installation locale

# Créer une nouvelle table
npx @e-xiste/drizzle-cli make:table

# Configurer l'outil
npx @e-xiste/drizzle-cli config

# Initialiser le projet
npx @e-xiste/drizzle-cli init

Création d'une nouvelle table

L'outil vous guidera à travers les étapes suivantes :

Saisir le nom de la table
Pour chaque colonne :
- Nom de la colonne
- Type de données (texte, nombre, date, relation, etc.)
- Options supplémentaires (nullable, unique, valeur par défaut, etc.)
Pour les relations :
- Sélectionner la table cible parmi les tables existantes
- Choisir le type de relation (one-to-one, one-to-many, many-to-one, many-to-many)
- Configurer les options de relation

Exemple d'utilisation :

$ drizzle-cli make:table

# ou

$ npx @e-xiste/drizzle-cli make:table

? Nom de la table : users
✓ Création de la table "users"

? Nom de la colonne : id
? Type de colonne : serial
? Clé primaire ? (O/n) : O
✓ Colonne "id" ajoutée

? Nom de la colonne : email
? Type de colonne : text
? Nullable ? (o/N) : N
? Unique ? (o/N) : O
✓ Colonne "email" ajoutée

? Ajouter une autre colonne ? (o/N) : N

✓ Table "users" créée avec succès !

Mise à jour d'une table existante

La même commande make:table détectera si la table existe déjà et proposera de la mettre à jour plutôt que d'en créer une nouvelle.

Configuration

Le CLI utilise TypeScript pour la génération de schéma. Vous pouvez utiliser la commande suivante pour configurer le CLI :

# Configuration interactive
drizzle-cli config --interactive
# OU
npx @e-xiste/drizzle-cli config --interactive

Vous pouvez également modifier directement le fichier drizzle.config.ts pour changer ces préférences.

Résolution des problèmes

Erreur "Command not found"

Si vous obtenez une erreur "Command not found" lors de l'exécution de drizzle-cli, assurez-vous que le package est correctement installé :

# Vérifier l'installation globale
npm list -g @e-xiste/drizzle-cli

# Vérifier l'installation locale
npm list @e-xiste/drizzle-cli

Structure du projet

drizzle-cli/
├── src/
│   ├── commands/
│   │   ├── makeTable.js
│   │   ├── config.js
│   │   └── init.js
│   ├── utils/
│   │   ├── promptUtils.js
│   │   ├── schemaUtils.js
│   │   ├── fileUtils.js
│   │   └── configUtils.js
│   └── index.js
├── schema/           # Fichiers de schéma générés
├── drizzle.config.ts # Configuration Drizzle générée
├── package.json
└── README.md

Commandes disponibles

make:table : Créer ou mettre à jour une table dans le schéma Drizzle
config : Configurer le CLI (chemin du fichier de schéma, extension de fichier, etc.)
init : Initialiser le projet avec un fichier de configuration

Types de colonnes pris en charge

serial : Entier à auto-incrémentation
text : Texte de n'importe quelle longueur
varchar : Chaîne de caractères de longueur variable
integer : Nombre entier
boolean : Booléen (vrai/faux)
date : Date sans heure
time : Heure sans date
timestamp : Date et heure
decimal : Nombre décimal avec précision
real : Nombre à virgule flottante
json : Données JSON
jsonb : Données JSON binaires
uuid : Identifiant unique universel
relation : Relation avec une autre table

Types de relations pris en charge

one-to-one : Un enregistrement dans la table A correspond à un enregistrement dans la table B
one-to-many : Un enregistrement dans la table A correspond à plusieurs enregistrements dans la table B
many-to-one : Plusieurs enregistrements dans la table A correspondent à un enregistrement dans la table B
many-to-many : Plusieurs enregistrements dans la table A correspondent à plusieurs enregistrements dans la table B