nestgen-cli 0.0.7

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Aristide Kamara
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/nestgen.js

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+
+import { execSync } from 'child_process';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+
+// ────── Resolve __dirname compatible ES Modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// ────── Définition du chemin du générateur
+const ROOT_PATH = process.env.NESTGEN_ROOT || path.resolve(__dirname, './nestjs-generator');
+const GENERATE_SCRIPT = path.join(ROOT_PATH, 'generate_project.sh');
+const ADD_MODULE_SCRIPT = path.join(ROOT_PATH, './features/add_module.sh');
+
+// ────── Logo CLI
+function printLogo() {
+    console.log(chalk.magentaBright(`
+███╗   ██╗███████╗███████╗████████╗ ██████╗ ███████╗███╗   ██╗
+████╗  ██║██╔════╝██╔════╝╚══██╔══╝██╔════╝ ██╔════╝████╗  ██║
+██╔██╗ ██║█████╗  ███████╗   ██║   ██║  ███╗█████╗  ██╔██╗ ██║
+██║╚██╗██║██╔══╝  ╚════██║   ██║   ██║   ██║██╔══╝  ██║╚██╗██║
+██║ ╚████║███████╗███████║   ██║   ╚██████╔╝███████╗██║ ╚████║
+╚═╝  ╚═══╝╚══════╝╚══════╝   ╚═╝    ╚═════╝ ╚══════╝╚═╝  ╚═══╝
+`));
+    console.log(chalk.cyan.bold('✨ NestGen CLI — Générateur modulaire NestJS'));
+}
+
+// ────── Helpers
+function isNestProject() {
+    return fs.existsSync(path.resolve('./src/app.module.ts'));
+}
+
+function parseModuleArgs(args) {
+    const moduleName = args[1];
+    const ormArg = args.find(arg => arg.startsWith('--orm='));
+    const orm = ormArg ? ormArg.split('=')[1] : 'typeorm';
+    return { moduleName, orm };
+}
+
+// ────── Commande : INIT
+async function askInitQuestions() {
+    return await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'projectName',
+            message: '📛 Nom du projet :',
+            default: 'my-app',
+        },
+        {
+            type: 'input',
+            name: 'projectPath',
+            message: '📁 Dossier cible :',
+            default: './',
+        },
+        {
+            type: 'list',
+            name: 'packageManager',
+            message: '📦 Package manager :',
+            choices: ['pnpm', 'yarn', 'npm'],
+            default: 'pnpm',
+        },
+        {
+            type: 'list',
+            name: 'orm',
+            message: '🧠 ORM :',
+            choices: ['typeorm', 'prisma'],
+            default: 'typeorm',
+        },
+        {
+            type: 'confirm',
+            name: 'withSwagger',
+            message: '📚 Activer Swagger ?',
+            default: true,
+        },
+        {
+            type: 'confirm',
+            name: 'withDocker',
+            message: '🐳 Activer Docker ?',
+            default: false,
+        },
+        {
+            type: 'confirm',
+            name: 'withGit',
+            message: '🔃 Initialiser Git ?',
+            default: true,
+        },
+        {
+            type: 'input',
+            name: 'modules',
+            message: '📦 Modules à générer (séparés par des espaces) :',
+            default: 'user',
+            filter: (input) => input.split(' ').map(s => s.trim()).filter(Boolean),
+        }
+    ]);
+}
+
+async function runInteractiveInit() {
+    printLogo();
+
+    if (!fs.existsSync(GENERATE_SCRIPT)) {
+        console.log(chalk.red(`❌ Script introuvable : ${GENERATE_SCRIPT}`));
+        process.exit(1);
+    }
+
+    const answers = await askInitQuestions();
+    const {
+        projectName,
+        projectPath,
+        packageManager,
+        orm,
+        withSwagger,
+        withDocker,
+        withGit,
+        modules,
+    } = answers;
+
+    const env = {
+        APP_NAME: projectName,
+        PROJECT_PATH: path.resolve(projectPath),
+        PM: packageManager,
+        ORM: orm,
+        WITH_SWAGGER: withSwagger ? 'y' : 'n',
+        WITH_DOCKER: withDocker ? 'y' : 'n',
+        WITH_GIT: withGit ? 'y' : 'n',
+        MODULES: modules.join(' '),
+    };
+
+    const envExport = Object.entries(env)
+        .map(([key, val]) => `${key}="${val}"`)
+        .join(' ');
+
+    console.log('\n🚀 Lancement de la génération du projet...\n');
+    try {
+        execSync(`env ${envExport} bash "${GENERATE_SCRIPT}"`, {
+            stdio: 'inherit',
+        });
+    } catch (err) {
+        console.error(chalk.red('❌ Une erreur est survenue pendant la génération.'));
+        process.exit(1);
+    }
+}
+
+// ────── Commande : MODULE
+async function runModuleGeneration(args) {
+    printLogo();
+
+    let moduleName, orm;
+
+    if (args.length > 1) {
+        ({ moduleName, orm } = parseModuleArgs(args));
+        if (!moduleName) {
+            console.log(chalk.red('❌ Tu dois fournir un nom de module.'));
+            process.exit(1);
+        }
+    } else {
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'moduleName',
+                message: '📦 Nom du module :',
+                validate: input => !!input || 'Le nom du module est requis',
+            },
+            {
+                type: 'list',
+                name: 'orm',
+                message: '🧠 ORM utilisé :',
+                choices: ['typeorm', 'prisma'],
+                default: 'typeorm',
+            },
+        ]);
+        moduleName = answers.moduleName;
+        orm = answers.orm;
+    }
+
+    if (!isNestProject()) {
+        console.log(chalk.red('❌ Aucun projet NestJS détecté dans ce dossier.'));
+        console.log('👉 Lance cette commande depuis un projet généré avec `nestgen init`.');
+        process.exit(1);
+    }
+
+    try {
+        console.log(chalk.cyan(`\n⚙️  Génération du module ${moduleName}...\n`));
+        execSync(`bash "${ADD_MODULE_SCRIPT}" "${moduleName}" "${orm}"`, {
+            stdio: 'inherit',
+        });
+    } catch (err) {
+        console.error(chalk.red('❌ Une erreur est survenue pendant la génération du module.'));
+        process.exit(1);
+    }
+}
+
+// ────── Entrée CLI
+const args = process.argv.slice(2);
+const command = args[0];
+
+switch (command) {
+    case 'init':
+        await runInteractiveInit();
+        break;
+
+    case 'module':
+        await runModuleGeneration(args);
+        break;
+
+    default:
+        printLogo();
+        console.log(chalk.gray(`
+📘 Commandes disponibles :
+  ▸ nestgen init                 → Génère un projet complet NestJS (interactive)
+  ▸ nestgen module [nom] [--orm=xxx]  → Génère un module (interactive ou CLI)
+  ▸ nestgen doctor              → Diagnostic de l’installation CLI
+`));
+        break;
+}

package/nestjs-generator/features/add_module.sh

@@ -0,0 +1,234 @@
+#!/bin/bash
+
+RAW_NAME=$1
+ORM=$2
+
+# ────── Charger les helpers ──────
+FEATURES_PATH="$(dirname "$0")"
+source "$FEATURES_PATH/utils.sh"
+source "$FEATURES_PATH/logger.sh"
+
+
+if [ -z "$RAW_NAME" ]; then
+  echo "❌ Tu dois passer un nom de module."
+  exit 1
+fi
+
+if [ -z "$ORM" ]; then
+  echo "❌ ORM manquant (typeorm ou prisma)."
+  exit 1
+fi
+
+# ────── Formatage ──────
+NAME=$(echo "$RAW_NAME" | tr '[:upper:]' '[:lower:]')
+PASCAL=$(echo "$NAME" | sed -E 's/(^|[-_])([a-z])/\u\2/g' | sed -E 's/[-_]//g')
+
+NAME=$(echo "$RAW_NAME" | tr '[:upper:]' '[:lower:]')
+PASCAL=$(echo "$NAME" | sed -E 's/(^|[-_])([a-z])/\U\2/g' | sed -E 's/[-_]//g')
+
+CAMEL=$(echo "$PASCAL" | sed -E 's/^([A-Z])/\L\1/')
+
+MODULE_DIR="src/app/$NAME"
+mkdir -p "$MODULE_DIR"/{core/{application/{commands,events,queries},domain/{entities,ports}},infrastructure/{adapters,persistences/repositories},interfaces/{controllers,dtos}}
+
+# ────── Entity ──────
+cat > "$MODULE_DIR/core/domain/entities/${NAME}.entity.ts" <<EOF
+export class $PASCAL {
+  constructor(
+    public readonly id: string,
+    public name: string,
+    public email: string,
+  ) {}
+}
+EOF
+
+# ────── Port ──────
+cat > "$MODULE_DIR/core/domain/ports/${NAME}.repository.ts" <<EOF
+import { $PASCAL } from '../entities/${NAME}.entity';
+
+export interface ${PASCAL}RepositoryPort {
+  save(${CAMEL}: $PASCAL): Promise<$PASCAL>;
+  findById(id: string): Promise<$PASCAL | null>;
+}
+EOF
+
+# ────── Command ──────
+cat > "$MODULE_DIR/core/application/commands/create-${NAME}.command.ts" <<EOF
+export class Create${PASCAL}Command {
+  constructor(public readonly name: string, public readonly email: string) {}
+}
+EOF
+
+# ────── Command Handler ──────
+cat > "$MODULE_DIR/core/application/commands/create-${NAME}.handler.ts" <<EOF
+import { CommandHandler, ICommandHandler } from '@nestjs/cqrs';
+import { Create${PASCAL}Command } from './create-${NAME}.command';
+import { $PASCAL } from '../../domain/entities/${NAME}.entity';
+import { ${PASCAL}RepositoryPort } from '../../domain/ports/${NAME}.repository';
+
+@CommandHandler(Create${PASCAL}Command)
+export class Create${PASCAL}Handler implements ICommandHandler<Create${PASCAL}Command> {
+  constructor(private readonly repo: ${PASCAL}RepositoryPort) {}
+
+  async execute(command: Create${PASCAL}Command): Promise<string> {
+    const $CAMEL = new $PASCAL(Date.now().toString(), command.name, command.email);
+    const saved = await this.repo.save($CAMEL);
+    return saved.id;
+  }
+}
+EOF
+
+# ────── DTO ──────
+cat > "$MODULE_DIR/interfaces/dtos/create-${NAME}.dto.ts" <<EOF
+import { IsEmail, IsString } from 'class-validator';
+
+export class Create${PASCAL}Dto {
+  @IsString()
+  name: string;
+
+  @IsEmail()
+  email: string;
+}
+EOF
+
+# ────── Controller ──────
+cat > "$MODULE_DIR/interfaces/controllers/${NAME}.controller.ts" <<EOF
+import { Controller, Post, Body } from '@nestjs/common';
+import { CommandBus } from '@nestjs/cqrs';
+import { Create${PASCAL}Command } from '../../core/application/commands/create-${NAME}.command';
+import { Create${PASCAL}Dto } from '../dtos/create-${NAME}.dto';
+
+@Controller('${NAME}s')
+export class ${PASCAL}Controller {
+  constructor(private readonly commandBus: CommandBus) {}
+
+  @Post()
+  async create(@Body() dto: Create${PASCAL}Dto) {
+    const id = await this.commandBus.execute(
+      new Create${PASCAL}Command(dto.name, dto.email)
+    );
+    return { id };
+  }
+}
+EOF
+
+# ────── Repository ORM ──────
+REPO_CLASS=""
+ENTITY_IMPORT=""
+REPO_PROVIDER=""
+
+if [ "$ORM" == "typeorm" ]; then
+  cat > "$MODULE_DIR/infrastructure/persistences/repositories/${NAME}.orm.ts" <<EOF
+import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
+
+@Entity('${NAME}s')
+export class ${PASCAL}Entity {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column()
+  name: string;
+
+  @Column({ unique: true })
+  email: string;
+}
+EOF
+
+  cat > "$MODULE_DIR/infrastructure/persistences/repositories/${NAME}.typeorm.repository.ts" <<EOF
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { ${PASCAL} } from '../../../core/domain/entities/${NAME}.entity';
+import { ${PASCAL}RepositoryPort } from '../../../core/domain/ports/${NAME}.repository';
+import { ${PASCAL}Entity } from './${NAME}.orm';
+
+@Injectable()
+export class ${PASCAL}TypeOrmRepository implements ${PASCAL}RepositoryPort {
+  constructor(@InjectRepository(${PASCAL}Entity) private readonly repo: Repository<${PASCAL}Entity>) {}
+
+  async save(${CAMEL}: $PASCAL): Promise<$PASCAL> {
+    const entity = this.repo.create(${CAMEL});
+    const saved = await this.repo.save(entity);
+    return new $PASCAL(saved.id, saved.name, saved.email);
+  }
+
+  async findById(id: string): Promise<$PASCAL | null> {
+    const found = await this.repo.findOneBy({ id });
+    return found ? new $PASCAL(found.id, found.name, found.email) : null;
+  }
+}
+EOF
+
+  REPO_CLASS="${PASCAL}TypeOrmRepository"
+  ENTITY_IMPORT="TypeOrmModule.forFeature([${PASCAL}Entity])"
+  REPO_PROVIDER="{
+      provide: '${PASCAL}RepositoryPort',
+      useClass: ${PASCAL}TypeOrmRepository,
+    }"
+
+elif [ "$ORM" == "prisma" ]; then
+  cat > "$MODULE_DIR/infrastructure/persistences/repositories/${NAME}.prisma.repository.ts" <<EOF
+import { Injectable } from '@nestjs/common';
+import { PrismaService } from '@/prisma.service';
+import { ${PASCAL} } from '../../../core/domain/entities/${NAME}.entity';
+import { ${PASCAL}RepositoryPort } from '../../../core/domain/ports/${NAME}.repository';
+
+@Injectable()
+export class ${PASCAL}PrismaRepository implements ${PASCAL}RepositoryPort {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async save(${CAMEL}: ${PASCAL}): Promise<${PASCAL}> {
+    const saved = await this.prisma.${NAME}.create({
+      data: {
+        id: ${CAMEL}.id,
+        name: ${CAMEL}.name,
+        email: ${CAMEL}.email,
+      },
+    });
+    return new ${PASCAL}(saved.id, saved.name, saved.email);
+  }
+
+  async findById(id: string): Promise<${PASCAL} | null> {
+    const found = await this.prisma.${NAME}.findUnique({ where: { id } });
+    return found ? new ${PASCAL}(found.id, found.name, found.email) : null;
+  }
+}
+EOF
+
+  REPO_CLASS="${PASCAL}PrismaRepository"
+  ENTITY_IMPORT=""
+  REPO_PROVIDER="{
+      provide: '${PASCAL}RepositoryPort',
+      useClass: ${PASCAL}PrismaRepository,
+    }"
+fi
+
+# ────── Module.ts ──────
+IMPORTS="import { Module } from '@nestjs/common';
+import { CqrsModule } from '@nestjs/cqrs';
+import { ${PASCAL}Controller } from './interfaces/controllers/${NAME}.controller';
+import { Create${PASCAL}Handler } from './core/application/commands/create-${NAME}.handler';
+import { $REPO_CLASS } from './infrastructure/persistences/repositories/${NAME}.${ORM}.repository';"
+
+if [ "$ORM" = "typeorm" ]; then
+  IMPORTS="$IMPORTS
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { ${PASCAL}Entity } from './infrastructure/persistences/repositories/${NAME}.orm';"
+fi
+
+echo "$IMPORTS
+
+@Module({
+  imports: [CqrsModule${ENTITY_IMPORT:+, $ENTITY_IMPORT}],
+  controllers: [${PASCAL}Controller],
+  providers: [
+    Create${PASCAL}Handler,
+    $REPO_CLASS,
+    $REPO_PROVIDER,
+  ],
+})
+export class ${PASCAL}Module {}
+" > "$MODULE_DIR/${NAME}.module.ts"
+
+bash "$(dirname "$0")/inject_module_to_app.sh" "$NAME" "$ORM"
+

package/nestjs-generator/features/docker.sh

@@ -0,0 +1,59 @@
+#!/bin/bash
+
+
+# ────── Charger les helpers ──────
+FEATURES_PATH="$(dirname "$0")/features"
+source "$FEATURES_PATH/utils.sh"
+source "$FEATURES_PATH/logger.sh"
+
+
+APP_NAME=$1
+
+cat > Dockerfile <<EOF
+FROM node:18-alpine
+WORKDIR /usr/src/app
+COPY package*.json ./
+RUN npm install
+COPY . .
+RUN npm run build
+CMD ["node", "dist/main"]
+EOF
+
+cat > docker-compose.yml <<EOF
+version: '3.9'
+
+services:
+  postgres:
+    image: postgres:15
+    restart: always
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: appdb
+    ports:
+      - "5432:5432"
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+
+  app:
+    build: .
+    ports:
+      - "3000:3000"
+    depends_on:
+      - postgres
+    env_file:
+      - .env
+    volumes:
+      - .:/usr/src/app
+    command: npm run start:dev
+
+volumes:
+  pgdata:
+EOF
+
+cat > .env <<EOF
+DATABASE_URL=postgresql://postgres:postgres@postgres:5432/appdb
+PORT=3000
+EOF
+
+echo "✅ Dockerfile, docker-compose et .env générés !"

package/nestjs-generator/features/git.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+# ────── Charger les helpers ──────
+FEATURES_PATH="$(dirname "$0")/features"
+source "$FEATURES_PATH/utils.sh"
+source "$FEATURES_PATH/logger.sh"
+
+
+git init
+git add .
+git commit -m "🚀 Initial commit (NestJS starter clean architecture)"
+echo "✅ Git initialisé et commité !"

package/nestjs-generator/features/inject_module_to_app.sh

@@ -0,0 +1,99 @@
+#!/bin/bash
+
+RAW_NAME=$1
+ORM=$2
+APP_MODULE="src/app.module.ts"
+MODULE_FILE="src/app/${RAW_NAME}/${RAW_NAME}.module.ts"
+
+if [ -z "$RAW_NAME" ]; then
+  echo "❌ Tu dois fournir un nom de module."
+  exit 1
+fi
+
+if [ ! -f "$MODULE_FILE" ]; then
+  echo "❌ Le fichier $MODULE_FILE est introuvable."
+  exit 1
+fi
+
+# 🧠 Extraire le vrai nom de la classe exportée
+MODULE_CLASS=$(grep -oE 'export class [A-Za-z0-9_]+' "$MODULE_FILE" | awk '{print $3}')
+
+if [ -z "$MODULE_CLASS" ]; then
+  echo "❌ Impossible de détecter la classe du module dans $MODULE_FILE"
+  exit 1
+fi
+
+MODULE_PATH="./app/${RAW_NAME}/${RAW_NAME}.module"
+
+# 🔧 Créer app.module.ts s'il n'existe pas
+if [ ! -f "$APP_MODULE" ]; then
+  echo "📄 Création de $APP_MODULE"
+  mkdir -p src
+  cat > "$APP_MODULE" <<EOF
+import { Module } from '@nestjs/common';
+
+@Module({
+  imports: [],
+})
+export class AppModule {}
+EOF
+fi
+
+# 🔌 Ajouter l'import du module s'il est absent
+IMPORT_LINE="import { $MODULE_CLASS } from '${MODULE_PATH}';"
+if ! grep -q "$IMPORT_LINE" "$APP_MODULE"; then
+  echo "🔧 Insertion de $MODULE_CLASS dans les imports du haut"
+  sed -i '' "1s|^|$IMPORT_LINE\n|" "$APP_MODULE"
+else
+  echo "ℹ️ Import $MODULE_CLASS déjà présent"
+fi
+
+# ➕ Ajouter dans imports: []
+if grep -q "imports: \[" "$APP_MODULE"; then
+  if ! grep -q "$MODULE_CLASS" "$APP_MODULE"; then
+    sed -i '' "s|imports: \[|imports: [$MODULE_CLASS, |" "$APP_MODULE"
+    echo "✅ $MODULE_CLASS injecté dans imports"
+  else
+    echo "ℹ️ $MODULE_CLASS déjà dans imports"
+  fi
+else
+  echo "❌ Aucun bloc imports: [] trouvé dans $APP_MODULE"
+fi
+
+# ➕ Ajouter CqrsModule si absent
+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é"
+fi
+
+# ➕ Ajouter TypeOrmModule si ORM = typeorm
+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
+
+  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,\
+    }), |" "$APP_MODULE"
+    echo "✅ TypeOrmModule.forRoot injecté"
+  else
+    echo "ℹ️ TypeOrmModule.forRoot déjà présent"
+  fi
+fi
+
+echo "🎯 Module $MODULE_CLASS injecté dans app.module.ts avec succès 🧩"

package/nestjs-generator/features/logger.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+# 🎨 Couleurs
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[1;34m'
+NC='\033[0m' # No Color
+
+log_info() {
+  echo -e "${BLUE}ℹ️  $1${NC}"
+}
+
+log_success() {
+  echo -e "${GREEN}✅ $1${NC}"
+}
+
+log_warn() {
+  echo -e "${YELLOW}⚠️  $1${NC}"
+}
+
+log_error() {
+  echo -e "${RED}❌ $1${NC}"
+}

package/nestjs-generator/features/path.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+get_cli_root() {
+  echo "$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+}
+
+get_features_path() {
+  echo "$(get_cli_root)/features"
+}

package/nestjs-generator/features/prisma.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+
+# ────── Charger les helpers ──────
+FEATURES_PATH="$(dirname "$0")/features"
+source "$FEATURES_PATH/utils.sh"
+source "$FEATURES_PATH/logger.sh"
+
+
+PM=$1
+APP_NAME=$2
+
+$PM install prisma --save-dev
+$PM install @prisma/client
+npx prisma init
+
+cat > .env <<EOF
+DATABASE_URL="postgresql://postgres:postgres@localhost:5432/$APP_NAME"
+EOF
+
+cat > prisma/schema.prisma <<EOF
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+EOF
+
+npx prisma generate
+
+echo "✅ Prisma initialisé avec succès !"

package/nestjs-generator/features/swagger.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+
+# ────── Charger les helpers ──────
+FEATURES_PATH="$(dirname "$0")/features"
+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';
+
+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

package/nestjs-generator/features/typeorm.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+
+PM=$1
+APP_NAME=$2
+
+# ────── 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
+
+log_success "✅ TypeORM installé avec succès"
+
+log_info "💡 TypeORM sera automatiquement configuré dans app.module.ts"

package/nestjs-generator/features/utils.sh

@@ -0,0 +1,26 @@
+#!/bin/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" ;;
+  esac
+}
+
+# ────── Vérifie si une commande est installée ──────
+assert_command_exists() {
+  local CMD=$1
+  if ! command -v "$CMD" &> /dev/null; then
+    echo "❌ Commande introuvable : $CMD"
+    echo "👉 Installe-la ou vérifie ton PATH"
+    exit 1
+  fi
+}
+
+# ────── Formatage ──────
+to_pascal_case() {
+  echo "$1" | sed -E 's/(^|-|_)([a-z])/\U\2/g'
+}

package/nestjs-generator/generate_project.sh

@@ -0,0 +1,143 @@
+#!/bin/bash
+
+# ────── INIT ──────
+set -e
+
+FEATURES_PATH="$(dirname "$0")/features"
+source "$FEATURES_PATH/utils.sh"
+source "$FEATURES_PATH/logger.sh"
+
+# ────── DEBUG MODE ──────
+DEBUG=false
+for arg in "$@"; do
+  [[ "$arg" == "--debug" ]] && DEBUG=true
+done
+
+debug_log() {
+  if [ "$DEBUG" = true ]; then
+    echo "🐞 [DEBUG] $1" | tee /dev/tty
+  fi
+}
+
+debug_log "Script lancé avec les arguments : $*"
+debug_log "Chemin du script courant : $(pwd)"
+debug_log "Features path : $FEATURES_PATH"
+
+# ────── INFOS UTILISATEUR ──────
+APP_NAME=${APP_NAME:-$(read -p "📛 Nom du projet : " tmp && echo "$tmp")}
+PROJECT_PATH=${PROJECT_PATH:-$(read -p "📁 Chemin d’installation (vide = ici) : " tmp && echo "${tmp:-$(pwd)}")}
+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
+
+# ────── Création du projet ──────
+log_info "Création du projet à $FULL_PATH"
+mkdir -p "$FULL_PATH"
+cd "$FULL_PATH" || {
+  log_error "Erreur : impossible de se déplacer dans $FULL_PATH"
+  exit 1
+}
+
+nest new . --package-manager "$PM" --skip-git || {
+  log_error "Échec de nest new"
+  exit 1
+}
+
+log_info "Installation des packages communs..."
+$PM $INSTALL_CMD @nestjs/cqrs class-validator class-transformer @nestjs/config
+
+# ────── ORM SETUP ──────
+case "$ORM" in
+  typeorm)
+    debug_log "Appel de typeorm.sh"
+    bash "$FEATURES_PATH/typeorm.sh" "$PM" "$APP_NAME"
+    ;;
+  prisma)
+    debug_log "Appel de prisma.sh"
+    bash "$FEATURES_PATH/prisma.sh" "$PM" "$APP_NAME"
+    ;;
+  *)
+    log_error "❌ ORM non reconnu : $ORM"
+    exit 1
+    ;;
+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"
+
+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é"
+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
+
+  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
+fi
+
+# Modules générés
+for MODULE in $MODULES; do
+  debug_log "Injection de $MODULE dans app.module.ts"
+  bash "$FEATURES_PATH/inject_module_to_app.sh" "$MODULE" "$ORM"
+done
+
+# ────── Résumé final ──────
+echo ""
+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"

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "nestgen-cli",
+  "version": "0.0.7",
+  "description": "NestGen CLI — Générateur modulaire NestJS (DDD, CQRS, Hexagonal)",
+  "files": [
+    "nestgen.js",
+    "nestjs-generator"
+  ],
+  "bin": {
+    "nestgen": "nestgen.js"
+  },
+  "author": "Aristide kamara bakarykamara52@gmail.com",
+  "license": "MIT",
+  "keywords": [
+    "nestjs",
+    "cli",
+    "ddd",
+    "cqrs",
+    "scaffold",
+    "generator",
+    "hexagonal"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/el-hack/nestgen-cli.git"
+  },
+  "type": "module",
+  "licenses": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "inquirer": "^9.0.0"
+  }
+}

package/readme.md

@@ -0,0 +1,175 @@
+# NestGen
+
+<div align="center">
+  <img src="https://raw.githubusercontent.com/outis25/nestgen-js/main/assets/logo.png" alt="NestGen Logo" width="200" />
+  <h3>Générateur modulaire autonome pour projets NestJS</h3>
+  <p>Architecture DDD • CQRS • Hexagonal • Prisma/TypeORM • Docker/Swagger</p>
+
+  ![npm](https://img.shields.io/npm/v/@outis25/nestgen?color=crimson&style=for-the-badge)
+  ![nestjs](https://img.shields.io/badge/NestJS-Scaffolded-red?style=for-the-badge&logo=nestjs)
+  ![standalone](https://img.shields.io/badge/100%25-Autonome-brightgreen?style=for-the-badge)
+  ![license](https://img.shields.io/npm/l/@outis25/nestgen?color=blue&style=for-the-badge)
+  ![downloads](https://img.shields.io/npm/dm/@outis25/nestgen?color=green&style=for-the-badge)
+</div>
+
+## 📋 Table des matières
+
+- [Introduction](#-introduction)
+- [Fonctionnalités](#-fonctionnalités)
+- [Installation](#-installation)
+- [Guide d'utilisation](#-guide-dutilisation)
+- [Architecture générée](#-architecture-générée)
+- [Roadmap](#-roadmap)
+- [FAQ](#-faq)
+- [Contribuer](#-contribuer)
+- [Licence](#-licence)
+
+## 🚀 Introduction
+
+**NestGen** est un générateur de code 100% autonome pour NestJS qui vous permet de créer rapidement des projets et des modules respectant les principes d'architecture avancés. Ce package n'a aucune dépendance externe et embarque tous les templates nécessaires pour générer des applications NestJS suivant les modèles Domain-Driven Design (DDD), Command Query Responsibility Segregation (CQRS) et l'architecture hexagonale.
+
+Idéal pour les développeurs qui souhaitent maintenir une architecture propre et évolutive, NestGen accélère la phase de setup et garantit la cohérence structurelle de votre application, le tout sans nécessiter d'installation ou de configuration supplémentaire.
+
+## ✨ Fonctionnalités
+
+- **100% autonome** - Aucune dépendance externe, tout est intégré
+- **Zéro configuration** - Fonctionne immédiatement après installation
+- **Génération complète** - Projets et modules prêts à l'emploi en quelques secondes
+- **Architecture avancée** - Support intégré pour DDD, CQRS et architecture hexagonale
+- **Templates embarqués** - Tous les templates sont inclus dans le package
+- **Support multiple d'ORM** - TypeORM et Prisma intégrés nativement
+- **DevOps ready** - Configurations Docker, Swagger et CI/CD incluses
+- **Mode interactif** - Interface CLI intuitive avec prompts pour une configuration guidée
+
+## 📦 Installation
+
+```bash
+npm install -g @outis25/nestgen
+```
+
+C'est tout! Aucune configuration supplémentaire n'est nécessaire. Tous les templates et dépendances sont embarqués dans le package.
+
+## 🔧 Guide d'utilisation
+
+### Initialiser un nouveau projet
+
+```bash
+nestgen init
+```
+
+Cette commande lance un assistant interactif qui vous guidera à travers les étapes de configuration :
+- Nom du projet
+- Répertoire d'installation
+- Sélection de l'ORM (TypeORM ou Prisma)
+- Modules à générer automatiquement
+- Options additionnelles (Git, Swagger, Docker, etc.)
+
+### Générer un nouveau module
+
+```bash
+nestgen module <nom-du-module> [options]
+```
+
+Options disponibles :
+- `--orm=<typeorm|prisma>` - Spécifie l'ORM à utiliser pour ce module
+- `--crud` - Génère les opérations CRUD de base
+- `--path=<chemin>` - Définit un chemin personnalisé pour le module
+
+Exemples :
+```bash
+nestgen module user --orm=typeorm
+nestgen module transaction --orm=prisma --crud
+```
+
+### Vérifier l'installation
+
+```bash
+nestgen doctor
+```
+
+Cette commande vérifie que :
+- Le package est correctement installé
+- Tous les templates embarqués sont disponibles
+- Aucune dépendance n'est manquante
+
+## 📁 Architecture générée
+
+NestGen génère une structure de projet suivant les meilleures pratiques d'architecture :
+
+```
+src/app/<module>/
+├── core/                   # Cœur du domaine métier
+│   ├── application/        # Cas d'utilisation
+│   │   ├── commands/       # Commandes CQRS
+│   │   ├── events/         # Événements domaine
+│   │   └── queries/        # Requêtes CQRS
+│   └── domain/             # Modèle du domaine
+│       ├── entities/       # Entités métier
+│       └── ports/          # Interfaces pour l'hexagonal
+├── infrastructure/         # Implémentations techniques
+│   ├── adapters/           # Adaptateurs pour l'hexagonal
+│   └── persistences/       # Couche de persistance
+│       └── repositories/   # Implémentations des repos
+└── interfaces/             # Points d'entrée de l'app
+    ├── controllers/        # Contrôleurs REST
+    └── dtos/               # Objets de transfert
+```
+
+Cette structure facilite :
+- La séparation des préoccupations
+- Les tests unitaires et d'intégration
+- L'évolutivité du code
+- Le remplacement des composants techniques
+
+## 🔮 Roadmap
+
+- ✅ Génération de projet complet
+- ✅ Génération de module modulaire (DDD, CQRS, Repo)
+- ✅ Support Prisma et TypeORM
+- ✅ Mode interactif
+- ✅ Docker, Swagger, Git
+- ✅ Templates intégrés
+- ✅ Package 100% autonome
+- ⬜ `nestgen resource <name>` (CRUD complet)
+- ⬜ `nestgen destroy module <name>`
+- ⬜ `nestgen preset ecommerce` (Templates d'applications)
+- ⬜ `nestgen --interactive` (menu CLI avancé)
+- ⬜ Support pour MongoDB et Mongoose
+- ⬜ Génération de tests unitaires et d'intégration
+
+## ❓ FAQ
+
+**Q: NestGen nécessite-t-il des dépendances externes ?**  
+R: Non, NestGen est 100% autonome. Tous les templates et outils nécessaires sont embarqués dans le package.
+
+**Q: Puis-je utiliser NestGen avec un projet NestJS existant ?**  
+R: Oui, vous pouvez ajouter des modules générés par NestGen à un projet existant. La structure générée s'intègre parfaitement aux projets NestJS standards.
+
+**Q: Comment puis-je personnaliser les templates générés ?**  
+R: Par défaut, NestGen utilise ses templates intégrés. Leurs structures sont optimisées pour les meilleures pratiques et ne nécessitent généralement pas de modifications.
+
+**Q: NestGen supporte-t-il les microservices ?**  
+R: Pas encore nativement, mais c'est prévu dans les prochaines versions. En attendant, vous pouvez adapter manuellement la structure générée.
+
+## 👥 Contribuer
+
+Les contributions sont les bienvenues ! Pour contribuer :
+
+1. Forkez le dépôt
+2. Créez une branche pour votre fonctionnalité (`git checkout -b feature/amazing-feature`)
+3. Commitez vos changements (`git commit -m 'feat: add amazing feature'`)
+4. Poussez vers la branche (`git push origin feature/amazing-feature`)
+5. Ouvrez une Pull Request
+
+<!-- Veuillez consulter le fichier `CONTRIBUTING.md` pour plus de détails. -->
+
+## 📄 Licence
+
+NestGen est distribué sous licence MIT. Voir le fichier `LICENSE` pour plus d'informations.
+
+---
+
+<div align="center">
+  <p>Développé avec ❤️ par <a href="https://github.com/el-hack">@el-hack</a></p>
+  <p>Si vous trouvez ce projet utile, n'hésitez pas à lui donner une ⭐️ sur GitHub !</p>
+</div>