@e-xiste/drizzle-cli

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 :

1. Initialiser le projet :

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

2. 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 :

1. Nom de la table : Entrez le nom de votre table
2. 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.)
3. 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 :

1. Saisir le nom de la table
2. 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.)
3. 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

Contribuer

Les contributions sont les bienvenues ! N'hésitez pas à soumettre une Pull Request.

Licence

MIT