nestgen-cli 0.1.0 → 0.2.1

package/nestjs-generator/features/configure_bootstrap.mjs

@@ -1,18 +1,21 @@
 import fs from 'node:fs';
 
-const [mainPath, swaggerEnabled] = process.argv.slice(2);
+const [mainPath, swaggerEnabled, operationsEnabled] = 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 operations = operationsEnabled === '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';
+${operations ? "import { StructuredLogger } from './operations/structured-logger.service';\n" : ''}
 
 async function bootstrap() {
-  const app = await NestFactory.create(AppModule);
+  const app = await NestFactory.create(AppModule${operations ? ', { bufferLogs: true }' : ''});
+${operations ? '  app.useLogger(app.get(StructuredLogger));\n  app.enableShutdownHooks();\n' : ''}
   app.useGlobalPipes(new ValidationPipe({
     whitelist: true,
     forbidNonWhitelisted: true,

package/nestjs-generator/features/operational_foundation.mjs

@@ -0,0 +1,210 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const [sourceDirectory, orm] = process.argv.slice(2);
+
+if (!sourceDirectory || !['typeorm', 'prisma'].includes(orm)) {
+    console.error('❌ Usage : operational_foundation.mjs <source-directory> <typeorm|prisma>');
+    process.exitCode = 1;
+} else {
+    const operationsDirectory = path.join(sourceDirectory, 'operations');
+    const appModule = path.join(sourceDirectory, 'app.module.ts');
+
+    if (!fs.existsSync(appModule)) {
+        console.error(`❌ AppModule introuvable : ${appModule}`);
+        process.exitCode = 1;
+    } else if (fs.existsSync(operationsDirectory)) {
+        console.error(`❌ ${operationsDirectory} existe déjà. Le socle d’exploitation n’a pas été remplacé.`);
+        process.exitCode = 1;
+    } else {
+        const databaseHealth =
+            orm === 'typeorm'
+                ? `import { Injectable } from '@nestjs/common';
+import { InjectDataSource } from '@nestjs/typeorm';
+import type { DataSource } from 'typeorm';
+
+@Injectable()
+export class DatabaseHealthService {
+  constructor(@InjectDataSource() private readonly dataSource: DataSource) {}
+
+  async check(): Promise<{ status: 'up' | 'down' }> {
+    try {
+      if (!this.dataSource.isInitialized) return { status: 'down' };
+      await this.dataSource.query('SELECT 1');
+      return { status: 'up' };
+    } catch {
+      return { status: 'down' };
+    }
+  }
+}
+`
+                : `import { Injectable } from '@nestjs/common';
+import { PrismaService } from '../prisma/prisma.service';
+
+@Injectable()
+export class DatabaseHealthService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async check(): Promise<{ status: 'up' | 'down' }> {
+    try {
+      await this.prisma.$queryRawUnsafe('SELECT 1');
+      return { status: 'up' };
+    } catch {
+      return { status: 'down' };
+    }
+  }
+}
+`;
+
+        const files = new Map([
+            [
+                'request-context.ts',
+                `import { AsyncLocalStorage } from 'node:async_hooks';
+
+export const requestContext = new AsyncLocalStorage<{ requestId: string }>();
+`,
+            ],
+            [
+                'request-id.middleware.ts',
+                `import { Injectable, type NestMiddleware } from '@nestjs/common';
+import { randomUUID } from 'node:crypto';
+import type { NextFunction, Request, Response } from 'express';
+import { requestContext } from './request-context';
+
+const REQUEST_ID = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/;
+
+@Injectable()
+export class RequestIdMiddleware implements NestMiddleware {
+  use(request: Request, response: Response, next: NextFunction): void {
+    const candidate = request.header('x-request-id');
+    const requestId = candidate && REQUEST_ID.test(candidate) ? candidate : randomUUID();
+    response.setHeader('x-request-id', requestId);
+    requestContext.run({ requestId }, next);
+  }
+}
+`,
+            ],
+            [
+                'structured-logger.service.ts',
+                `import { Injectable, type LoggerService } from '@nestjs/common';
+import { requestContext } from './request-context';
+
+const SENSITIVE_KEY = /password|secret|token|authorization|cookie|api[-_]?key/i;
+
+export function redact(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(redact);
+  if (!value || typeof value !== 'object') return value;
+  if (value instanceof Error) return { name: value.name, message: value.message };
+  return Object.fromEntries(
+    Object.entries(value).map(([key, nested]) => [key, SENSITIVE_KEY.test(key) ? '[REDACTED]' : redact(nested)]),
+  );
+}
+
+@Injectable()
+export class StructuredLogger implements LoggerService {
+  log(message: unknown, ...optional: unknown[]): void {
+    this.write('log', message, optional);
+  }
+
+  error(message: unknown, ...optional: unknown[]): void {
+    this.write('error', message, optional);
+  }
+
+  warn(message: unknown, ...optional: unknown[]): void {
+    this.write('warn', message, optional);
+  }
+
+  debug(message: unknown, ...optional: unknown[]): void {
+    this.write('debug', message, optional);
+  }
+
+  verbose(message: unknown, ...optional: unknown[]): void {
+    this.write('verbose', message, optional);
+  }
+
+  private write(level: string, message: unknown, optional: unknown[]): void {
+    const context = requestContext.getStore();
+    const record = {
+      timestamp: new Date().toISOString(),
+      level,
+      message: typeof message === 'string' ? message : redact(message),
+      ...(context ? { requestId: context.requestId } : {}),
+      ...(optional.length > 0 ? { details: redact(optional) } : {}),
+    };
+    process[level === 'error' ? 'stderr' : 'stdout'].write(JSON.stringify(record) + '\\n');
+  }
+}
+`,
+            ],
+            ['database-health.service.ts', databaseHealth],
+            [
+                'health.controller.ts',
+                `import { Controller, Get, ServiceUnavailableException } from '@nestjs/common';
+import { DatabaseHealthService } from './database-health.service';
+
+@Controller('health')
+export class HealthController {
+  constructor(private readonly databaseHealth: DatabaseHealthService) {}
+
+  @Get('live')
+  live(): { status: 'ok'; checks: { application: 'up' } } {
+    return { status: 'ok', checks: { application: 'up' } };
+  }
+
+  @Get('ready')
+  async ready(): Promise<{ status: 'ok'; checks: { database: 'up' } }> {
+    const database = await this.databaseHealth.check();
+    if (database.status === 'down') {
+      throw new ServiceUnavailableException({ status: 'error', checks: { database: 'down' } });
+    }
+    return { status: 'ok', checks: { database: 'up' } };
+  }
+}
+`,
+            ],
+            [
+                'operations.module.ts',
+                `import { MiddlewareConsumer, Module, type NestModule } from '@nestjs/common';
+${orm === 'prisma' ? "import { PrismaModule } from '../prisma/prisma.module';\n" : ''}import { DatabaseHealthService } from './database-health.service';
+import { HealthController } from './health.controller';
+import { RequestIdMiddleware } from './request-id.middleware';
+import { StructuredLogger } from './structured-logger.service';
+
+@Module({
+  imports: [${orm === 'prisma' ? 'PrismaModule' : ''}],
+  controllers: [HealthController],
+  providers: [DatabaseHealthService, RequestIdMiddleware, StructuredLogger],
+  exports: [StructuredLogger],
+})
+export class OperationsModule implements NestModule {
+  configure(consumer: MiddlewareConsumer): void {
+    consumer.apply(RequestIdMiddleware).forRoutes('*');
+  }
+}
+`,
+            ],
+            [
+                'README.md',
+                `# Socle d’exploitation
+
+Cette option est locale au projet et ne requiert aucun service externe. Elle expose :
+
+- \`GET /health/live\` : le processus Nest peut répondre ; aucun appel de dépendance n’est fait.
+- \`GET /health/ready\` : le processus et la base PostgreSQL sont prêts. Une base indisponible retourne \`503\` avec \`{ status: 'error', checks: { database: 'down' } }\`.
+
+Chaque réponse reçoit \`x-request-id\`. Une valeur cliente sûre est conservée ; sinon NestGen en crée une. Le logger Nest produit un JSON par ligne avec cet identifiant, et masque récursivement les clés contenant \`password\`, \`secret\`, \`token\`, \`authorization\`, \`cookie\` ou \`apiKey\`.
+
+\`main.ts\` active \`enableShutdownHooks()\`. Ainsi, \`SIGTERM\` et \`SIGINT\` ferment le contexte Nest ; TypeORM ferme sa connexion et Prisma exécute son \`onModuleDestroy\` existant. Les migrations restent explicites et ne sont jamais appliquées par ces endpoints.
+`,
+            ],
+        ]);
+
+        fs.mkdirSync(operationsDirectory, { recursive: true });
+        try {
+            for (const [name, content] of files) fs.writeFileSync(path.join(operationsDirectory, name), content);
+        } catch (error) {
+            fs.rmSync(operationsDirectory, { recursive: true, force: true });
+            throw error;
+        }
+    }
+}

package/nestjs-generator/features/operations.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+ORM=${1:?ORM requis}
+FEATURES_PATH="$(dirname "$0")"
+
+if [[ "$ORM" != "typeorm" && "$ORM" != "prisma" ]]; then
+  echo "❌ ORM non supporté : $ORM" >&2
+  exit 1
+fi
+
+node "$FEATURES_PATH/operational_foundation.mjs" src "$ORM"
+node "$FEATURES_PATH/update_app_module.mjs" src/app.module.ts OperationsModule './operations/operations.module' "$ORM"
+
+echo "✅ Socle d’exploitation configuré : /health/live et /health/ready."

package/nestjs-generator/features/preflight.mjs

@@ -1,48 +1,6 @@
-import fs from 'node:fs';
-import path from 'node:path';
+import { inspectProject } from '../../dist/engine/project-preflight.js';
 
-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),
-    };
-}
+export { inspectProject };
 
 if (import.meta.url === `file://${process.argv[1]}`) {
     try {

package/nestjs-generator/generate_project.sh

@@ -87,7 +87,12 @@ if [ "$WITH_SWAGGER" = "y" ]; then
   run_step "Configuration Swagger" bash "$FEATURES_PATH/swagger.sh" "$PM"
 fi
 
-run_step "Configuration du bootstrap Nest" node "$FEATURES_PATH/configure_bootstrap.mjs" src/main.ts "$WITH_SWAGGER"
+WITH_OPERATIONS=${WITH_OPERATIONS:-$(read -p "🩺 Activer le socle d’exploitation ? (y/n) : " tmp && echo "$tmp")}
+if [ "$WITH_OPERATIONS" = "y" ]; then
+  run_step "Configuration du socle d’exploitation" bash "$FEATURES_PATH/operations.sh" "$ORM"
+fi
+
+run_step "Configuration du bootstrap Nest" node "$FEATURES_PATH/configure_bootstrap.mjs" src/main.ts "$WITH_SWAGGER" "$WITH_OPERATIONS"
 
 WITH_GIT=${WITH_GIT:-$(read -p "🔃 Initialiser Git ? (y/n) : " tmp && echo "$tmp")}
 if [ "$WITH_GIT" = "y" ]; then
@@ -109,5 +114,6 @@ echo "📦 Package manager : $PM"
 echo "🧠 ORM : $ORM"
 if [ "$WITH_DOCKER" = "y" ]; then echo "🐳 Docker activé"; fi
 if [ "$WITH_SWAGGER" = "y" ]; then echo "📚 Swagger activé"; fi
+if [ "$WITH_OPERATIONS" = "y" ]; then echo "🩺 Socle d’exploitation activé"; fi
 if [ "$WITH_GIT" = "y" ]; then echo "🔃 Git initialisé"; fi
 if [ -n "$MODULES" ]; then echo "📦 Modules générés : $MODULES"; fi

package/package.json

@@ -1,9 +1,10 @@
 {
     "name": "nestgen-cli",
-    "version": "0.1.0",
+    "version": "0.2.1",
     "description": "NestGen CLI — Générateur modulaire NestJS (DDD, CQRS, Hexagonal)",
     "files": [
         "dist",
+        "examples",
         "nestgen.js",
         "nestjs-generator"
     ],
@@ -35,24 +36,30 @@
         "check": "npm run typecheck && eslint .",
         "format": "prettier --write .",
         "format:check": "prettier --check .",
-        "prepack": "npm run build && npm run check && npm run format:check && npm test",
+        "prepack": "npm run build && npm run check && npm run docs:check && npm run landing:check && npm run format:check && npm test && npm run test:example",
         "test": "node --test",
         "test:package": "node scripts/package-smoke.mjs",
+        "test:package-manager": "node scripts/package-manager-lockfile-integration.mjs",
         "test:prisma": "node scripts/prisma-integration.mjs",
         "test:docker": "node scripts/docker-config-integration.mjs",
+        "test:example": "node scripts/example-store-api-integration.mjs",
         "test:typeorm": "node scripts/typeorm-http-integration.mjs",
+        "release:verify": "node scripts/release-verify.mjs",
+        "release:verify-remote": "node scripts/release-verify-remote.mjs",
+        "docs:check": "node scripts/docs-contract.mjs",
+        "landing:check": "node scripts/landing-contract.mjs",
         "typecheck": "tsc -p tsconfig.json --noEmit"
     },
     "licenses": "MIT",
     "dependencies": {
         "chalk": "^5.3.0",
         "inquirer": "^9.0.0",
+        "prettier": "^3.9.9",
         "typescript": "^5.9.3"
     },
     "devDependencies": {
         "@eslint/js": "^9.39.5",
         "@types/node": "^24.19.0",
-        "eslint": "^9.39.5",
-        "prettier": "^3.9.9"
+        "eslint": "^9.39.5"
     }
 }