nestgen-cli 0.0.7 → 0.1.0

package/nestjs-generator/features/prisma.sh

@@ -1,21 +1,32 @@
-#!/bin/bash
+#!/usr/bin/env bash
+
+set -euo pipefail
 
 # ────── Charger les helpers ──────
-FEATURES_PATH="$(dirname "$0")/features"
+FEATURES_PATH="$(dirname "$0")"
 source "$FEATURES_PATH/utils.sh"
 source "$FEATURES_PATH/logger.sh"
 
 
-PM=$1
-APP_NAME=$2
+PM=${1:?Package manager requis}
+APP_NAME=${2:?Nom_application_requis}
+
+if [ -e prisma/schema.prisma ]; then
+  echo "❌ prisma/schema.prisma existe déjà. Aucune configuration Prisma n'a été remplacée."
+  exit 1
+fi
 
-$PM install prisma --save-dev
-$PM install @prisma/client
-npx prisma init
+pm_add_dev "$PM" prisma@6
+pm_add "$PM" @prisma/client@6
+pm_exec "$PM" prisma init
 
+if [ ! -e .env ]; then
 cat > .env <<EOF
 DATABASE_URL="postgresql://postgres:postgres@localhost:5432/$APP_NAME"
 EOF
+else
+  echo "ℹ️  .env existe déjà et a été conservé."
+fi
 
 cat > prisma/schema.prisma <<EOF
 generator client {
@@ -28,6 +39,35 @@ datasource db {
 }
 EOF
 
-npx prisma generate
+mkdir -p src/prisma
+cat > src/prisma/prisma.service.ts <<'EOF'
+import { Injectable, OnModuleDestroy, OnModuleInit } from '@nestjs/common';
+import { PrismaClient } from '@prisma/client';
+
+@Injectable()
+export class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy {
+  async onModuleInit(): Promise<void> {
+    await this.$connect();
+  }
+
+  async onModuleDestroy(): Promise<void> {
+    await this.$disconnect();
+  }
+}
+EOF
+
+cat > src/prisma/prisma.module.ts <<'EOF'
+import { Global, Module } from '@nestjs/common';
+import { PrismaService } from './prisma.service';
+
+@Global()
+@Module({
+  providers: [PrismaService],
+  exports: [PrismaService],
+})
+export class PrismaModule {}
+EOF
+
+pm_exec "$PM" prisma generate
 
 echo "✅ Prisma initialisé avec succès !"

package/nestjs-generator/features/resource_name.mjs

@@ -0,0 +1,57 @@
+const RESOURCE_NAME_PATTERN = /^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$/i;
+const ROUTE_PATTERN = /^[a-z][a-z0-9-]*$/;
+const TABLE_PATTERN = /^[a-z][a-z0-9_]*$/;
+
+function fail(message) {
+    throw new Error(`Nom de ressource invalide : ${message}`);
+}
+
+function pluralize(word) {
+    if (/(?:s|x|z|ch|sh)$/i.test(word)) return `${word}es`;
+    if (/[^aeiou]y$/i.test(word)) return `${word.slice(0, -1)}ies`;
+    return `${word}s`;
+}
+
+export function describeResource(rawName, options = {}) {
+    const name = String(rawName ?? '').trim();
+    if (!RESOURCE_NAME_PATTERN.test(name)) {
+        fail('il doit commencer par une lettre et ne contenir que des lettres, chiffres, tirets ou underscores.');
+    }
+
+    const segments = name.toLowerCase().split(/[-_]/);
+    const singular = segments.join('-');
+    const plural = options.plural
+        ? String(options.plural).trim().toLowerCase()
+        : `${segments.slice(0, -1).join('-')}${segments.length > 1 ? '-' : ''}${pluralize(segments.at(-1))}`;
+    const route = options.route ? String(options.route).trim().toLowerCase() : plural;
+    const table = options.table ? String(options.table).trim().toLowerCase() : plural.replaceAll('-', '_');
+
+    if (!ROUTE_PATTERN.test(plural)) fail('le pluriel doit être une ressource kebab-case.');
+    if (!ROUTE_PATTERN.test(route)) fail('la route doit être une ressource kebab-case.');
+    if (!TABLE_PATTERN.test(table)) fail('la table doit être une ressource snake_case.');
+
+    const pascal = segments.map((segment) => `${segment[0].toUpperCase()}${segment.slice(1)}`).join('');
+    return {
+        name: singular,
+        pascal,
+        camel: `${pascal[0].toLowerCase()}${pascal.slice(1)}`,
+        plural,
+        route,
+        table,
+    };
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+    try {
+        const [rawName] = process.argv.slice(2);
+        const resource = describeResource(rawName, {
+            plural: process.env.RESOURCE_PLURAL,
+            route: process.env.RESOURCE_ROUTE,
+            table: process.env.RESOURCE_TABLE,
+        });
+        for (const [key, value] of Object.entries(resource)) console.log(`${key.toUpperCase()}=${value}`);
+    } catch (error) {
+        console.error(`❌ ${error.message}`);
+        process.exitCode = 1;
+    }
+}

package/nestjs-generator/features/swagger.sh

@@ -1,27 +1,14 @@
-#!/bin/bash
+#!/usr/bin/env bash
+
+set -euo pipefail
 
 # ────── Charger les helpers ──────
-FEATURES_PATH="$(dirname "$0")/features"
+FEATURES_PATH="$(dirname "$0")"
 source "$FEATURES_PATH/utils.sh"
 source "$FEATURES_PATH/logger.sh"
 
 
-PM=$1
-
-$PM install @nestjs/swagger swagger-ui-express
-
-# Ajout dans main.ts (à faire manuellement ou via automatisation)
-echo ""
-echo "📘 Pour activer Swagger, ajoute ceci dans main.ts :"
-echo ""
-cat <<'DOC'
-import { SwaggerModule, DocumentBuilder } from '@nestjs/swagger';
+PM=${1:?Package manager requis}
 
-const config = new DocumentBuilder()
-  .setTitle('API Docs')
-  .setDescription('The API description')
-  .setVersion('1.0')
-  .build();
-const document = SwaggerModule.createDocument(app, config);
-SwaggerModule.setup('api', app, document);
-DOC
+pm_add "$PM" @nestjs/swagger@12 swagger-ui-express@5
+log_success "Swagger sera activé sur /api dans src/main.ts."

package/nestjs-generator/features/typeorm.sh

@@ -1,19 +1,80 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
-PM=$1
-APP_NAME=$2
+set -euo pipefail
+
+PM=${1:?Package manager requis}
+APP_NAME=${2:?Nom_application_requis}
 
 # ────── Charger les helpers ──────
 FEATURES_PATH="$(dirname "$0")"
 source "$FEATURES_PATH/utils.sh"
 source "$FEATURES_PATH/logger.sh"
 
-INSTALL_CMD=$(get_install_cmd "$PM")
-
 log_info "📦 Installation de TypeORM et PostgreSQL..."
 
-$PM $INSTALL_CMD @nestjs/typeorm typeorm pg
+pm_add "$PM" @nestjs/typeorm@12 typeorm@0.3 pg@8 dotenv@16
+pm_add_dev "$PM" ts-node@10
+
+mkdir -p src/database/migrations
+
+cat > src/database/typeorm.config.ts <<'EOF'
+import type { TypeOrmModuleOptions } from '@nestjs/typeorm';
+
+function required(name: string): string {
+  const value = process.env[name];
+  if (!value) throw new Error(`Variable d'environnement manquante : ${name}`);
+  return value;
+}
+
+export function typeOrmOptions(): TypeOrmModuleOptions {
+  return {
+    type: 'postgres',
+    host: required('DATABASE_HOST'),
+    port: Number(process.env.DATABASE_PORT ?? 5432),
+    username: required('DATABASE_USER'),
+    password: required('DATABASE_PASSWORD'),
+    database: required('DATABASE_NAME'),
+    autoLoadEntities: true,
+    synchronize: false,
+    migrationsRun: false,
+    migrations: ['dist/database/migrations/*.js'],
+  };
+}
+EOF
+
+cat > src/database/data-source.ts <<'EOF'
+import 'dotenv/config';
+import { DataSource, type DataSourceOptions } from 'typeorm';
+import { typeOrmOptions } from './typeorm.config';
+
+const options = typeOrmOptions();
+
+export default new DataSource({
+  ...(options as DataSourceOptions),
+  entities: ['src/**/*.entity{.ts,.js}'],
+  migrations: ['src/database/migrations/*{.ts,.js}'],
+});
+EOF
+
+cat > src/database/migrations/0000000000000-InitialSchema.ts <<'EOF'
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class InitialSchema0000000000000 implements MigrationInterface {
+  async up(_queryRunner: QueryRunner): Promise<void> {}
+  async down(_queryRunner: QueryRunner): Promise<void> {}
+}
+EOF
+
+if [ ! -e .env.example ]; then
+  cat > .env.example <<'EOF'
+DATABASE_HOST=localhost
+DATABASE_PORT=5432
+DATABASE_USER=postgres
+DATABASE_PASSWORD=change-me
+DATABASE_NAME=appdb
+EOF
+fi
 
 log_success "✅ TypeORM installé avec succès"
 
-log_info "💡 TypeORM sera automatiquement configuré dans app.module.ts"
+log_info "💡 TypeORM utilise src/database/typeorm.config.ts et src/database/data-source.ts pour des migrations explicites."

package/nestjs-generator/features/update_app_module.mjs

@@ -0,0 +1,146 @@
+import fs from 'node:fs';
+
+const [appModulePath, moduleClass, modulePath, orm] = process.argv.slice(2);
+
+function fail(message) {
+    throw new Error(`Impossible de mettre à jour AppModule : ${message}`);
+}
+
+function findMatching(source, start, open, close) {
+    let depth = 0;
+    let quote = null;
+    let escaped = false;
+    let lineComment = false;
+    let blockComment = false;
+
+    for (let index = start; index < source.length; index += 1) {
+        const character = source[index];
+        const next = source[index + 1];
+
+        if (lineComment) {
+            if (character === '\n') lineComment = false;
+            continue;
+        }
+        if (blockComment) {
+            if (character === '*' && next === '/') {
+                blockComment = false;
+                index += 1;
+            }
+            continue;
+        }
+        if (quote) {
+            if (!escaped && character === quote) quote = null;
+            escaped = !escaped && character === '\\';
+            if (character !== '\\') escaped = false;
+            continue;
+        }
+        if (character === '/' && next === '/') {
+            lineComment = true;
+            index += 1;
+            continue;
+        }
+        if (character === '/' && next === '*') {
+            blockComment = true;
+            index += 1;
+            continue;
+        }
+        if (character === '"' || character === "'" || character === '`') {
+            quote = character;
+            continue;
+        }
+        if (character === open) depth += 1;
+        if (character === close) {
+            depth -= 1;
+            if (depth === 0) return index;
+        }
+    }
+
+    fail(`délimiteur ${open}${close} non fermé.`);
+}
+
+function findDecoratorObject(source) {
+    const decoratorMatch = /@Module\s*\(/.exec(source);
+    if (!decoratorMatch) fail('décorateur @Module introuvable.');
+
+    const objectStart = source.indexOf('{', decoratorMatch.index + decoratorMatch[0].length);
+    if (objectStart === -1) fail('objet du décorateur @Module introuvable.');
+
+    return {
+        start: objectStart,
+        end: findMatching(source, objectStart, '{', '}'),
+    };
+}
+
+function findImportsArray(source, object) {
+    const propertyPattern = /\bimports\s*:\s*\[/g;
+    let match;
+
+    while ((match = propertyPattern.exec(source)) !== null) {
+        if (match.index > object.end) break;
+        const before = source.slice(object.start + 1, match.index);
+        let depth = 0;
+        for (const character of before) {
+            if (character === '{') depth += 1;
+            if (character === '}') depth -= 1;
+        }
+        if (depth !== 0) continue;
+
+        const arrayStart = match.index + match[0].lastIndexOf('[');
+        return { start: arrayStart, end: findMatching(source, arrayStart, '[', ']') };
+    }
+
+    fail('tableau imports dans @Module introuvable ou non supporté.');
+}
+
+function containsToken(items, token) {
+    const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`\\b${escaped}\\b`).test(items);
+}
+
+function appendImports(source, array, additions) {
+    if (additions.length === 0) return source;
+
+    const current = source.slice(array.start + 1, array.end);
+    const separator = current.trim() === '' ? '' : current.trimEnd().endsWith(',') ? '\n' : ',\n';
+    const indentation = current.includes('\n') ? (current.match(/\n([ \t]*)[^\n]*$/)?.[1] ?? '    ') : '';
+    const inserted = additions.map((item) => `${indentation}${item}`).join(',\n');
+    const replacement =
+        current.trim() === ''
+            ? current.includes('\n')
+                ? `\n${inserted}\n  `
+                : inserted
+            : `${current}${separator}${inserted}`;
+
+    return `${source.slice(0, array.start + 1)}${replacement}${source.slice(array.end)}`;
+}
+
+function addImport(source, line) {
+    return source.includes(line) ? source : `${line}\n${source}`;
+}
+
+try {
+    let source = fs.readFileSync(appModulePath, 'utf8');
+    const object = findDecoratorObject(source);
+    const array = findImportsArray(source, object);
+    const currentImports = source.slice(array.start + 1, array.end);
+    const additions = [];
+
+    if (!containsToken(currentImports, 'CqrsModule')) additions.push('CqrsModule');
+    if (!containsToken(currentImports, moduleClass)) additions.push(moduleClass);
+    if (orm === 'typeorm' && !/\bTypeOrmModule\.forRoot(?:Async)?\s*\(/.test(currentImports)) {
+        additions.unshift('TypeOrmModule.forRootAsync({ useFactory: typeOrmOptions })');
+    }
+
+    source = appendImports(source, array, additions);
+    source = addImport(source, `import { ${moduleClass} } from '${modulePath}';`);
+    source = addImport(source, "import { CqrsModule } from '@nestjs/cqrs';");
+    if (orm === 'typeorm') {
+        source = addImport(source, "import { typeOrmOptions } from './database/typeorm.config';");
+        source = addImport(source, "import { TypeOrmModule } from '@nestjs/typeorm';");
+    }
+
+    fs.writeFileSync(appModulePath, source);
+} catch (error) {
+    console.error(`❌ ${error.message}`);
+    process.exitCode = 1;
+}

package/nestjs-generator/features/utils.sh

@@ -1,12 +1,55 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
-# ────── Commande d'installation adaptée au package manager ──────
-get_install_cmd() {
-  local PM=$1
-  case "$PM" in
-    yarn) echo "add" ;;
-    pnpm|npm) echo "install" ;;
-    *) echo "install" ;;
+NEST_CLI_VERSION="12.0.0"
+
+assert_package_manager() {
+  local package_manager=$1
+  case "$package_manager" in
+    npm|pnpm|yarn) assert_command_exists "$package_manager" ;;
+    *)
+      echo "❌ Package manager non supporté : $package_manager. Valeurs acceptées : npm, pnpm, yarn."
+      return 1
+      ;;
+  esac
+}
+
+pm_add() {
+  local package_manager=$1
+  shift
+  case "$package_manager" in
+    npm) npm install "$@" ;;
+    pnpm) pnpm add "$@" ;;
+    yarn) yarn add "$@" ;;
+  esac
+}
+
+pm_add_dev() {
+  local package_manager=$1
+  shift
+  case "$package_manager" in
+    npm) npm install --save-dev "$@" ;;
+    pnpm) pnpm add --save-dev "$@" ;;
+    yarn) yarn add --dev "$@" ;;
+  esac
+}
+
+pm_exec() {
+  local package_manager=$1
+  shift
+  case "$package_manager" in
+    npm) npm exec -- "$@" ;;
+    pnpm) pnpm exec "$@" ;;
+    yarn) yarn exec "$@" ;;
+  esac
+}
+
+nest_new() {
+  local package_manager=$1
+  local destination=$2
+  case "$package_manager" in
+    npm) npx --yes "@nestjs/cli@${NEST_CLI_VERSION}" new "$destination" --package-manager npm --skip-git ;;
+    pnpm) pnpm dlx "@nestjs/cli@${NEST_CLI_VERSION}" new "$destination" --package-manager pnpm --skip-git ;;
+    yarn) yarn dlx "@nestjs/cli@${NEST_CLI_VERSION}" new "$destination" --package-manager yarn --skip-git ;;
   esac
 }
 
@@ -16,11 +59,6 @@ assert_command_exists() {
   if ! command -v "$CMD" &> /dev/null; then
     echo "❌ Commande introuvable : $CMD"
     echo "👉 Installe-la ou vérifie ton PATH"
-    exit 1
+    return 1
   fi
 }
-
-# ────── Formatage ──────
-to_pascal_case() {
-  echo "$1" | sed -E 's/(^|-|_)([a-z])/\U\2/g'
-}

package/nestjs-generator/generate_project.sh

@@ -1,9 +1,10 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
 # ────── INIT ──────
-set -e
+set -euo pipefail
 
-FEATURES_PATH="$(dirname "$0")/features"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+FEATURES_PATH="$SCRIPT_DIR/features"
 source "$FEATURES_PATH/utils.sh"
 source "$FEATURES_PATH/logger.sh"
 
@@ -19,6 +20,20 @@ debug_log() {
   fi
 }
 
+run_step() {
+  local step=$1
+  shift
+
+  log_info "$step"
+  if "$@"; then
+    return 0
+  else
+    local status=$?
+    log_error "$step a échoué (code $status)."
+    exit "$status"
+  fi
+}
+
 debug_log "Script lancé avec les arguments : $*"
 debug_log "Chemin du script courant : $(pwd)"
 debug_log "Features path : $FEATURES_PATH"
@@ -30,14 +45,8 @@ FULL_PATH="$PROJECT_PATH/$APP_NAME"
 PM=${PM:-$(read -p "📦 Package manager (npm/yarn/pnpm) : " tmp && echo "$tmp")}
 ORM=${ORM:-$(read -p "🧠 ORM ? (typeorm/prisma) : " tmp && echo "$tmp")}
 
-INSTALL_CMD=$(get_install_cmd "$PM")
-debug_log "Install command : $PM $INSTALL_CMD"
-
-# ────── Vérification de Nest CLI ──────
-if ! command -v nest &> /dev/null; then
-  log_warn "Nest CLI non installée. Installation avec npm..."
-  npm install -g @nestjs/cli
-fi
+run_step "Vérification du package manager" assert_package_manager "$PM"
+debug_log "Package manager : $PM ; Nest CLI local : $NEST_CLI_VERSION"
 
 # ────── Création du projet ──────
 log_info "Création du projet à $FULL_PATH"
@@ -47,23 +56,19 @@ cd "$FULL_PATH" || {
   exit 1
 }
 
-nest new . --package-manager "$PM" --skip-git || {
-  log_error "Échec de nest new"
-  exit 1
-}
+run_step "Création du projet NestJS" nest_new "$PM" .
 
-log_info "Installation des packages communs..."
-$PM $INSTALL_CMD @nestjs/cqrs class-validator class-transformer @nestjs/config
+run_step "Installation des packages communs" pm_add "$PM" @nestjs/cqrs@12 @nestjs/config@4 class-validator@0.14 class-transformer@0.5
 
 # ────── ORM SETUP ──────
 case "$ORM" in
   typeorm)
     debug_log "Appel de typeorm.sh"
-    bash "$FEATURES_PATH/typeorm.sh" "$PM" "$APP_NAME"
+    run_step "Configuration de TypeORM" bash "$FEATURES_PATH/typeorm.sh" "$PM" "$APP_NAME"
     ;;
   prisma)
     debug_log "Appel de prisma.sh"
-    bash "$FEATURES_PATH/prisma.sh" "$PM" "$APP_NAME"
+    run_step "Configuration de Prisma" bash "$FEATURES_PATH/prisma.sh" "$PM" "$APP_NAME"
     ;;
   *)
     log_error "❌ ORM non reconnu : $ORM"
@@ -73,62 +78,27 @@ esac
 
 # ────── Docker, Swagger, Git ──────
 WITH_DOCKER=${WITH_DOCKER:-$(read -p "🐳 Activer Docker ? (y/n) : " tmp && echo "$tmp")}
-[ "$WITH_DOCKER" = "y" ] && bash "$FEATURES_PATH/docker.sh" "$APP_NAME"
+if [ "$WITH_DOCKER" = "y" ]; then
+  run_step "Configuration Docker" bash "$FEATURES_PATH/docker.sh" "$APP_NAME" "$PM"
+fi
 
 WITH_SWAGGER=${WITH_SWAGGER:-$(read -p "📚 Activer Swagger ? (y/n) : " tmp && echo "$tmp")}
-[ "$WITH_SWAGGER" = "y" ] && bash "$FEATURES_PATH/swagger.sh" "$PM"
-
-WITH_GIT=${WITH_GIT:-$(read -p "🔃 Initialiser Git ? (y/n) : " tmp && echo "$tmp")}
-[ "$WITH_GIT" = "y" ] && bash "$FEATURES_PATH/git.sh"
-
-# ────── Modules à générer ──────
-MODULES=${MODULES:-$(read -p "👤 Modules à générer (séparés par espaces) : " tmp && echo "$tmp")}
-for MODULE in $MODULES; do
-  debug_log "Génération du module $MODULE"
-  bash "$FEATURES_PATH/add_module.sh" "$MODULE" "$ORM"
-done
-
-# ────── Injection dans app.module.ts ──────
-APP_MODULE="src/app.module.ts"
-
-# CqrsModule
-if ! grep -q "CqrsModule" "$APP_MODULE"; then
-  sed -i '' "1i\\
-import { CqrsModule } from '@nestjs/cqrs';
-" "$APP_MODULE"
-  sed -i '' "s|imports: \[|imports: [CqrsModule, |" "$APP_MODULE"
-  echo "✅ CqrsModule injecté"
+if [ "$WITH_SWAGGER" = "y" ]; then
+  run_step "Configuration Swagger" bash "$FEATURES_PATH/swagger.sh" "$PM"
 fi
 
-# TypeOrmModule
-if [ "$ORM" = "typeorm" ]; then
-  if ! grep -q "TypeOrmModule" "$APP_MODULE"; then
-    sed -i '' "1i\\
-import { TypeOrmModule } from '@nestjs/typeorm';
-" "$APP_MODULE"
-    echo "✅ Import de TypeOrmModule ajouté"
-  fi
+run_step "Configuration du bootstrap Nest" node "$FEATURES_PATH/configure_bootstrap.mjs" src/main.ts "$WITH_SWAGGER"
 
-  if ! grep -q "TypeOrmModule.forRoot" "$APP_MODULE"; then
-    sed -i '' -E 's/(imports: \[[^]]*)(])/\1\
-    TypeOrmModule.forRoot({\
-      type: '\''postgres'\'',\
-      host: '\''localhost'\'',\
-      port: 5432,\
-      username: '\''postgres'\'',\
-      password: '\''postgres'\'',\
-      database: '\''appdb'\'',\
-      synchronize: true,\
-      autoLoadEntities: true,\
-    }), \2/g' "$APP_MODULE"
-    echo "✅ TypeOrmModule.forRoot injecté"
-  fi
+WITH_GIT=${WITH_GIT:-$(read -p "🔃 Initialiser Git ? (y/n) : " tmp && echo "$tmp")}
+if [ "$WITH_GIT" = "y" ]; then
+  run_step "Initialisation Git" bash "$FEATURES_PATH/git.sh"
 fi
 
-# Modules générés
+# ────── Modules à générer ──────
+MODULES=${MODULES-$(read -p "👤 Modules à générer (séparés par espaces) : " tmp && echo "$tmp")}
 for MODULE in $MODULES; do
-  debug_log "Injection de $MODULE dans app.module.ts"
-  bash "$FEATURES_PATH/inject_module_to_app.sh" "$MODULE" "$ORM"
+  debug_log "Génération du module $MODULE"
+  run_step "Génération du module $MODULE" bash "$FEATURES_PATH/add_module.sh" "$MODULE" "$ORM"
 done
 
 # ────── Résumé final ──────
@@ -137,7 +107,7 @@ log_success "✅ Projet NestJS \"$APP_NAME\" généré avec succès 🎉"
 echo "📁 Localisation : $FULL_PATH"
 echo "📦 Package manager : $PM"
 echo "🧠 ORM : $ORM"
-[ "$WITH_DOCKER" = "y" ] && echo "🐳 Docker activé"
-[ "$WITH_SWAGGER" = "y" ] && echo "📚 Swagger activé"
-[ "$WITH_GIT" = "y" ] && echo "🔃 Git initialisé"
-[ -n "$MODULES" ] && echo "📦 Modules générés : $MODULES"
+if [ "$WITH_DOCKER" = "y" ]; then echo "🐳 Docker activé"; fi
+if [ "$WITH_SWAGGER" = "y" ]; then echo "📚 Swagger activé"; fi
+if [ "$WITH_GIT" = "y" ]; then echo "🔃 Git initialisé"; fi
+if [ -n "$MODULES" ]; then echo "📦 Modules générés : $MODULES"; fi