nestgen-cli 0.0.7 → 0.1.0

package/nestjs-generator/features/add_module.sh

@@ -1,7 +1,9 @@
 #!/bin/bash
 
-RAW_NAME=$1
-ORM=$2
+set -euo pipefail
+
+RAW_NAME=${1:-}
+ORM=${2:-}
 
 # ────── Charger les helpers ──────
 FEATURES_PATH="$(dirname "$0")"
@@ -9,33 +11,68 @@ source "$FEATURES_PATH/utils.sh"
 source "$FEATURES_PATH/logger.sh"
 
 
-if [ -z "$RAW_NAME" ]; then
-  echo "❌ Tu dois passer un nom de module."
+if [[ ! "$RAW_NAME" =~ ^[A-Za-z][A-Za-z0-9_-]*$ ]]; then
+  log_error "Le nom du module doit commencer par une lettre et ne contenir que des lettres, chiffres, tirets ou underscores."
+  exit 1
+fi
+
+if [[ "$ORM" != "typeorm" && "$ORM" != "prisma" ]]; then
+  log_error "ORM non supporté : ${ORM:-vide}. Valeurs acceptées : typeorm, prisma."
   exit 1
 fi
 
-if [ -z "$ORM" ]; then
-  echo "❌ ORM manquant (typeorm ou prisma)."
+# ────── Formatage portable ──────
+if ! RESOURCE_DATA=$(node "$FEATURES_PATH/resource_name.mjs" "$RAW_NAME"); then
+  log_error "Impossible de normaliser le nom de la ressource."
   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')
+while IFS='=' read -r key value; do
+  case "$key" in
+    NAME) NAME=$value ;;
+    PASCAL) PASCAL=$value ;;
+    CAMEL) CAMEL=$value ;;
+    PLURAL) PLURAL=$value ;;
+    ROUTE) ROUTE=$value ;;
+    TABLE) TABLE=$value ;;
+  esac
+done <<< "$RESOURCE_DATA"
+
+if [[ -z "${NAME:-}" || -z "${PASCAL:-}" || -z "${CAMEL:-}" || -z "${ROUTE:-}" || -z "${TABLE:-}" ]]; then
+  log_error "Impossible de normaliser le nom de la ressource."
+  exit 1
+fi
 
-NAME=$(echo "$RAW_NAME" | tr '[:upper:]' '[:lower:]')
-PASCAL=$(echo "$NAME" | sed -E 's/(^|[-_])([a-z])/\U\2/g' | sed -E 's/[-_]//g')
+REPOSITORY_TOKEN="${PASCAL}RepositoryToken"
 
-CAMEL=$(echo "$PASCAL" | sed -E 's/^([A-Z])/\L\1/')
+PROJECT_ROOT="$(pwd -P)"
+SOURCE_ROOT="$PROJECT_ROOT/src/app"
+
+if ! node "$FEATURES_PATH/preflight.mjs" "$PROJECT_ROOT" "$ORM" >/dev/null; then
+  log_error "Le projet cible ne satisfait pas les préconditions de génération."
+  exit 1
+fi
+
+if [ -L "$PROJECT_ROOT/src" ] || [ -L "$SOURCE_ROOT" ]; then
+  log_error "Les liens symboliques ne sont pas pris en charge dans src/app."
+  exit 1
+fi
+
+mkdir -p "$SOURCE_ROOT"
+MODULE_DIR="$SOURCE_ROOT/$NAME"
+
+if [ -e "$MODULE_DIR" ] || [ -L "$MODULE_DIR" ]; then
+  log_error "Le module $NAME existe déjà. Aucune modification n'a été appliquée."
+  exit 1
+fi
 
-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 readonly id: string | undefined,
     public name: string,
     public email: string,
   ) {}
@@ -46,6 +83,8 @@ EOF
 cat > "$MODULE_DIR/core/domain/ports/${NAME}.repository.ts" <<EOF
 import { $PASCAL } from '../entities/${NAME}.entity';
 
+export const ${REPOSITORY_TOKEN} = Symbol('${PASCAL}RepositoryPort');
+
 export interface ${PASCAL}RepositoryPort {
   save(${CAMEL}: $PASCAL): Promise<$PASCAL>;
   findById(id: string): Promise<$PASCAL | null>;
@@ -61,17 +100,20 @@ EOF
 
 # ────── Command Handler ──────
 cat > "$MODULE_DIR/core/application/commands/create-${NAME}.handler.ts" <<EOF
+import { Inject } from '@nestjs/common';
 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';
+import { ${PASCAL}RepositoryPort, ${REPOSITORY_TOKEN} } 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) {}
+  constructor(
+    @Inject(${REPOSITORY_TOKEN}) 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 $CAMEL = new $PASCAL(undefined, command.name, command.email);
     const saved = await this.repo.save($CAMEL);
     return saved.id;
   }
@@ -98,7 +140,7 @@ 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')
+@Controller('${ROUTE}')
 export class ${PASCAL}Controller {
   constructor(private readonly commandBus: CommandBus) {}
 
@@ -121,7 +163,7 @@ if [ "$ORM" == "typeorm" ]; then
   cat > "$MODULE_DIR/infrastructure/persistences/repositories/${NAME}.orm.ts" <<EOF
 import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
 
-@Entity('${NAME}s')
+@Entity('${TABLE}')
 export class ${PASCAL}Entity {
   @PrimaryGeneratedColumn('uuid')
   id: string;
@@ -147,7 +189,10 @@ 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 entity = this.repo.create({
+      name: ${CAMEL}.name,
+      email: ${CAMEL}.email,
+    });
     const saved = await this.repo.save(entity);
     return new $PASCAL(saved.id, saved.name, saved.email);
   }
@@ -162,7 +207,7 @@ EOF
   REPO_CLASS="${PASCAL}TypeOrmRepository"
   ENTITY_IMPORT="TypeOrmModule.forFeature([${PASCAL}Entity])"
   REPO_PROVIDER="{
-      provide: '${PASCAL}RepositoryPort',
+      provide: ${REPOSITORY_TOKEN},
       useClass: ${PASCAL}TypeOrmRepository,
     }"
 
@@ -198,7 +243,7 @@ EOF
   REPO_CLASS="${PASCAL}PrismaRepository"
   ENTITY_IMPORT=""
   REPO_PROVIDER="{
-      provide: '${PASCAL}RepositoryPort',
+      provide: ${REPOSITORY_TOKEN},
       useClass: ${PASCAL}PrismaRepository,
     }"
 fi
@@ -208,6 +253,7 @@ 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 { ${REPOSITORY_TOKEN} } from './core/domain/ports/${NAME}.repository';
 import { $REPO_CLASS } from './infrastructure/persistences/repositories/${NAME}.${ORM}.repository';"
 
 if [ "$ORM" = "typeorm" ]; then
@@ -223,7 +269,6 @@ echo "$IMPORTS
   controllers: [${PASCAL}Controller],
   providers: [
     Create${PASCAL}Handler,
-    $REPO_CLASS,
     $REPO_PROVIDER,
   ],
 })
@@ -231,4 +276,3 @@ export class ${PASCAL}Module {}
 " > "$MODULE_DIR/${NAME}.module.ts"
 
 bash "$(dirname "$0")/inject_module_to_app.sh" "$NAME" "$ORM"
-

package/nestjs-generator/features/configure_bootstrap.mjs

@@ -0,0 +1,39 @@
+import fs from 'node:fs';
+
+const [mainPath, swaggerEnabled] = process.argv.slice(2);
+
+if (!mainPath || !fs.existsSync(mainPath)) {
+    console.error(`❌ Bootstrap Nest introuvable : ${mainPath ?? 'src/main.ts'}`);
+    process.exitCode = 1;
+} else {
+    const swagger = swaggerEnabled === 'y';
+    const source = `import { ValidationPipe } from '@nestjs/common';
+import { NestFactory } from '@nestjs/core';
+${swagger ? "import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';\n" : ''}import { AppModule } from './app.module';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  app.useGlobalPipes(new ValidationPipe({
+    whitelist: true,
+    forbidNonWhitelisted: true,
+    transform: true,
+  }));
+${
+    swagger
+        ? `
+  const config = new DocumentBuilder()
+    .setTitle('API')
+    .setDescription('Documentation de l’API')
+    .setVersion('1.0')
+    .build();
+  SwaggerModule.setup('api', app, SwaggerModule.createDocument(app, config));
+`
+        : ''
+}
+  await app.listen(process.env.PORT ?? 3000);
+}
+
+void bootstrap();
+`;
+    fs.writeFileSync(mainPath, source);
+}

package/nestjs-generator/features/docker.sh

@@ -1,59 +1,192 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
+set -euo pipefail
 
-# ────── Charger les helpers ──────
-FEATURES_PATH="$(dirname "$0")/features"
-source "$FEATURES_PATH/utils.sh"
-source "$FEATURES_PATH/logger.sh"
+APP_NAME=${1:?Nom_application_requis}
+PM=${2:-npm}
 
+case "$PM" in
+  npm|pnpm|yarn) ;;
+  *)
+    echo "❌ Package manager non supporté pour Docker : $PM."
+    exit 1
+    ;;
+esac
 
-APP_NAME=$1
+for file in Dockerfile compose.yaml .dockerignore; do
+  if [ -e "$file" ]; then
+    echo "❌ $file existe déjà. Aucune configuration Docker n'a été remplacée."
+    exit 1
+  fi
+done
 
-cat > Dockerfile <<EOF
-FROM node:18-alpine
-WORKDIR /usr/src/app
-COPY package*.json ./
-RUN npm install
+case "$PM" in
+  npm)
+    cat > Dockerfile <<'DOCKERFILE'
+FROM node:24-alpine AS base
+WORKDIR /app
+
+FROM base AS dependencies
+COPY package.json package-lock.json ./
+RUN npm ci
+
+FROM dependencies AS development
+COPY . .
+CMD ["npm", "run", "start:dev"]
+
+FROM dependencies AS build
 COPY . .
 RUN npm run build
-CMD ["node", "dist/main"]
-EOF
 
-cat > docker-compose.yml <<EOF
-version: '3.9'
+FROM base AS production-dependencies
+COPY package.json package-lock.json ./
+RUN npm ci --omit=dev && npm cache clean --force && mkdir -p node_modules
+
+FROM node:24-alpine AS production
+ENV NODE_ENV=production
+WORKDIR /app
+COPY --chown=node:node --from=production-dependencies /app/node_modules ./node_modules
+COPY --chown=node:node --from=build /app/dist ./dist
+USER node
+EXPOSE 3000
+CMD ["node", "dist/main.js"]
+DOCKERFILE
+    ;;
+  pnpm)
+    cat > Dockerfile <<'DOCKERFILE'
+FROM node:24-alpine AS base
+WORKDIR /app
+RUN corepack enable
+
+FROM base AS dependencies
+COPY package.json pnpm-lock.yaml ./
+RUN pnpm install --frozen-lockfile
+
+FROM dependencies AS development
+COPY . .
+CMD ["pnpm", "run", "start:dev"]
+
+FROM dependencies AS build
+COPY . .
+RUN pnpm run build
+
+FROM base AS production-dependencies
+COPY package.json pnpm-lock.yaml ./
+RUN pnpm install --prod --frozen-lockfile && mkdir -p node_modules
+
+FROM node:24-alpine AS production
+ENV NODE_ENV=production
+WORKDIR /app
+COPY --chown=node:node --from=production-dependencies /app/node_modules ./node_modules
+COPY --chown=node:node --from=build /app/dist ./dist
+USER node
+EXPOSE 3000
+CMD ["node", "dist/main.js"]
+DOCKERFILE
+    ;;
+  yarn)
+    cat > Dockerfile <<'DOCKERFILE'
+FROM node:24-alpine AS base
+WORKDIR /app
+RUN corepack enable
 
+FROM base AS dependencies
+COPY package.json yarn.lock ./
+RUN yarn install --frozen-lockfile
+
+FROM dependencies AS development
+COPY . .
+CMD ["yarn", "start:dev"]
+
+FROM dependencies AS build
+COPY . .
+RUN yarn build
+
+FROM base AS production-dependencies
+COPY package.json yarn.lock ./
+RUN yarn install --production=true --frozen-lockfile && mkdir -p node_modules
+
+FROM node:24-alpine AS production
+ENV NODE_ENV=production
+WORKDIR /app
+COPY --chown=node:node --from=production-dependencies /app/node_modules ./node_modules
+COPY --chown=node:node --from=build /app/dist ./dist
+USER node
+EXPOSE 3000
+CMD ["node", "dist/main.js"]
+DOCKERFILE
+    ;;
+esac
+
+cat > compose.yaml <<COMPOSE
 services:
   postgres:
-    image: postgres:15
-    restart: always
+    image: postgres:16-alpine
     environment:
-      POSTGRES_USER: postgres
-      POSTGRES_PASSWORD: postgres
-      POSTGRES_DB: appdb
+      POSTGRES_DB: \${POSTGRES_DB:-appdb}
+      POSTGRES_USER: \${POSTGRES_USER:-nestgen}
+      POSTGRES_PASSWORD: \${POSTGRES_PASSWORD:-nestgen-local-only}
     ports:
-      - "5432:5432"
+      - "\${POSTGRES_PORT:-5432}:5432"
     volumes:
-      - pgdata:/var/lib/postgresql/data
+      - postgres-data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U \$\$POSTGRES_USER -d \$\$POSTGRES_DB"]
+      interval: 5s
+      timeout: 3s
+      retries: 20
+      start_period: 5s
 
   app:
-    build: .
+    build:
+      context: .
+      target: development
+    command: \${NESTGEN_DEV_COMMAND:-$PM run start:dev}
+    environment:
+      DATABASE_HOST: postgres
+      DATABASE_PORT: 5432
+      DATABASE_NAME: \${POSTGRES_DB:-appdb}
+      DATABASE_USER: \${POSTGRES_USER:-nestgen}
+      DATABASE_PASSWORD: \${POSTGRES_PASSWORD:-nestgen-local-only}
+      PORT: \${PORT:-3000}
     ports:
-      - "3000:3000"
-    depends_on:
-      - postgres
-    env_file:
-      - .env
+      - "\${PORT:-3000}:3000"
     volumes:
-      - .:/usr/src/app
-    command: npm run start:dev
+      - .:/app
+      - app-node-modules:/app/node_modules
+    depends_on:
+      postgres:
+        condition: service_healthy
 
 volumes:
-  pgdata:
-EOF
+  postgres-data:
+  app-node-modules:
+COMPOSE
+
+cat > .dockerignore <<'IGNORE'
+node_modules
+dist
+coverage
+.git
+.env
+.env.*
+!.env.example
+npm-debug.log*
+yarn-debug.log*
+pnpm-debug.log*
+IGNORE
 
-cat > .env <<EOF
-DATABASE_URL=postgresql://postgres:postgres@postgres:5432/appdb
+if [ ! -e .env.example ]; then
+  cat > .env.example <<'ENV'
+# Variables utilisées par compose.yaml en développement local.
+POSTGRES_DB=appdb
+POSTGRES_USER=nestgen
+POSTGRES_PASSWORD=change-me-before-sharing
+POSTGRES_PORT=5432
 PORT=3000
-EOF
+ENV
+else
+  echo "ℹ️  .env.example existe déjà et a été conservé."
+fi
 
-echo "✅ Dockerfile, docker-compose et .env générés !"
+echo "✅ Docker de développement et image de production générés pour $APP_NAME ($PM)."

package/nestjs-generator/features/git.sh

@@ -1,7 +1,9 @@
-#!/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"
 

package/nestjs-generator/features/inject_module_to_app.sh

@@ -1,35 +1,41 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
-RAW_NAME=$1
-ORM=$2
+set -euo pipefail
+
+RAW_NAME=${1:-}
+ORM=${2:-}
 APP_MODULE="src/app.module.ts"
 MODULE_FILE="src/app/${RAW_NAME}/${RAW_NAME}.module.ts"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+if [[ -z "$RAW_NAME" ]]; then
+  echo "❌ Tu dois fournir un nom de module." >&2
+  exit 1
+fi
 
-if [ -z "$RAW_NAME" ]; then
-  echo "❌ Tu dois fournir un nom de module."
+if [[ "$ORM" != "typeorm" && "$ORM" != "prisma" ]]; then
+  echo "❌ ORM non supporté : ${ORM:-vide}." >&2
   exit 1
 fi
 
-if [ ! -f "$MODULE_FILE" ]; then
-  echo "❌ Le fichier $MODULE_FILE est introuvable."
+if [[ ! -f "$MODULE_FILE" ]]; then
+  echo "❌ Le fichier $MODULE_FILE est introuvable." >&2
   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"
+if [[ -z "$MODULE_CLASS" ]]; then
+  echo "❌ Impossible de détecter la classe du module dans $MODULE_FILE" >&2
   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
+if [[ ! -f "$APP_MODULE" ]]; then
   echo "📄 Création de $APP_MODULE"
   mkdir -p src
-  cat > "$APP_MODULE" <<EOF
+  cat > "$APP_MODULE" <<'EOF'
 import { Module } from '@nestjs/common';
 
 @Module({
@@ -39,61 +45,8 @@ 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
+# Le transformateur prépare le nouveau contenu en mémoire et n'écrit qu'après
+# avoir validé le décorateur @Module et son tableau imports.
+node "$SCRIPT_DIR/update_app_module.mjs" "$APP_MODULE" "$MODULE_CLASS" "$MODULE_PATH" "$ORM"
 
 echo "🎯 Module $MODULE_CLASS injecté dans app.module.ts avec succès 🧩"

package/nestjs-generator/features/preflight.mjs

@@ -0,0 +1,55 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+function error(message) {
+    throw new Error(`Préflight échoué : ${message}`);
+}
+
+export function inspectProject(projectRoot, orm) {
+    const packagePath = path.join(projectRoot, 'package.json');
+    const appModulePath = path.join(projectRoot, 'src', 'app.module.ts');
+    const nestCliPath = path.join(projectRoot, 'nest-cli.json');
+
+    if (!fs.existsSync(packagePath))
+        error('package.json introuvable. Exécute la commande à la racine d’un projet NestJS.');
+    if (!fs.existsSync(appModulePath))
+        error(
+            'src/app.module.ts introuvable. Les workspaces et structures personnalisées ne sont pas encore supportés.',
+        );
+
+    const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+    const nestCli = fs.existsSync(nestCliPath) ? JSON.parse(fs.readFileSync(nestCliPath, 'utf8')) : null;
+    if (nestCli?.monorepo) error('les workspaces Nest ne sont pas encore supportés. Cible une application autonome.');
+
+    const dependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    const missing = ['@nestjs/common', '@nestjs/core', '@nestjs/cqrs'];
+    if (orm === 'typeorm') missing.push('@nestjs/typeorm', 'typeorm');
+    if (orm === 'prisma') missing.push('@prisma/client');
+    const unavailable = missing.filter((dependency) => !dependencies[dependency]);
+    if (unavailable.length) error(`dépendances manquantes : ${unavailable.join(', ')}.`);
+
+    const appModule = fs.readFileSync(appModulePath, 'utf8');
+    if (!/@Module\s*\(/.test(appModule)) error('le décorateur @Module est introuvable dans src/app.module.ts.');
+
+    return {
+        appModulePath,
+        packageManager: fs.existsSync(path.join(projectRoot, 'pnpm-lock.yaml'))
+            ? 'pnpm'
+            : fs.existsSync(path.join(projectRoot, 'yarn.lock'))
+              ? 'yarn'
+              : fs.existsSync(path.join(projectRoot, 'package-lock.json'))
+                ? 'npm'
+                : null,
+        hasRootTypeOrmConnection: /\bTypeOrmModule\.forRoot\s*\(/.test(appModule),
+    };
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+    try {
+        const [projectRoot, orm] = process.argv.slice(2);
+        process.stdout.write(`${JSON.stringify(inspectProject(projectRoot, orm))}\n`);
+    } catch (cause) {
+        console.error(`❌ ${cause.message}`);
+        process.exitCode = 1;
+    }
+}