nestgen-cli 0.0.7 → 0.2.1

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

@@ -0,0 +1,13 @@
+import { inspectProject } from '../../dist/engine/project-preflight.js';
+
+export { inspectProject };
+
+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;
+    }
+}

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;
+}