nestcraftx 0.1.7 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nestcraftx",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "CLI to generate scalable NestJS projects with Clean Architecture and Clean Code",
   "main": "bin/nestcraft.js",
   "bin": {

package/unutils.txt

@@ -1,250 +1,431 @@
-`import { Injectable } from '@nestjs/common';
-import { ${capitalize(
-          entity
-        )}Entity } from '${entityPath}/domain/entities/${entity}.entity';
-        /* a decommenter apres migration des schema prisma */
-/* import { ${capitalize(entity)} as Prisma${capitalize(
-          entity
-        )} } from '@prisma/client'; */
-import { Create${capitalize(entity)}Dto,Update${capitalize(
-          entity
-        )}Dto } from 'src/${entity}/application/dtos/${entity}.dto';
-
-@Injectable()
-export class ${capitalize(entity)}Mapper {
-  toDomain(data: any/* Prisma${capitalize(entity)} */): ${capitalize(
-          entity
-        )}Entity {
-    return new ${capitalize(entity)}Entity(
-      data.id,
-      // ajoute ici tous les autres champs selon l'ordre de l'entité
-      // exemple:
-      // data.name,
-      // data.description,
-      // ...
-      data.createdAt,
-      data.updatedAt,
+/*ancien input*/
+import * as readline from "readline-sync";
+import * as fs from "fs";
+
+export async function getUserInputs2() {
+  console.log("\n🔹🔹🔹 Configuration du projet 🔹🔹🔹\n");
+
+  const dataBases = [
+    {
+      name: "postgresql",
+      label: "PostgreSQL",
+      ormOptions: ["prisma", "typeorm"], // Choix des ORM supportés
+      required: [
+        {
+          title: "Nom d’utilisateur PostgreSQL",
+          envVar: "POSTGRES_USER",
+          defaultValue: "postgres",
+          hideEchoBack: false,
+        },
+        {
+          title: "Mot de passe PostgreSQL",
+          envVar: "POSTGRES_PASSWORD",
+          defaultValue: null,
+          hideEchoBack: true,
+        },
+        {
+          title: "Nom de la base de données",
+          envVar: "POSTGRES_DB",
+          defaultValue: "mydb",
+          hideEchoBack: false,
+        },
+        {
+          title: "Hôte PostgreSQL",
+          envVar: "POSTGRES_HOST",
+          defaultValue: "localhost",
+          hideEchoBack: false,
+        },
+        {
+          title: "Port PostgreSQL",
+          envVar: "POSTGRES_PORT",
+          defaultValue: "5432",
+          hideEchoBack: false,
+        },
+      ],
+    },
+    /* {
+      name: "mysql",
+      label: "MySQL / MariaDB",
+      ormOptions: ["prisma", "typeorm"], // Choix des ORM supportés
+      required: [
+        {
+          title: "Nom d’utilisateur MySQL",
+          envVar: "MYSQL_USER",
+          defaultValue: "root",
+          hideEchoBack: false,
+        },
+        {
+          title: "Mot de passe MySQL",
+          envVar: "MYSQL_PASSWORD",
+          defaultValue: null,
+          hideEchoBack: true,
+        },
+        {
+          title: "Nom de la base de données",
+          envVar: "MYSQL_DB",
+          defaultValue: "mydb",
+          hideEchoBack: false,
+        },
+        {
+          title: "Hôte MySQL",
+          envVar: "MYSQL_HOST",
+          defaultValue: "localhost",
+          hideEchoBack: false,
+        },
+        {
+          title: "Port MySQL",
+          envVar: "MYSQL_PORT",
+          defaultValue: "3306",
+          hideEchoBack: false,
+        },
+      ],
+    },
+    {
+      name: "mongodb",
+      label: "MongoDB",
+      ormOptions: ["mongoose"], // Choix d'ORM pour MongoDB
+      required: [
+        {
+          title: "URL de connexion MongoDB",
+          envVar: "MONGO_URI",
+          defaultValue: "mongodb://localhost:27017",
+          hideEchoBack: false,
+        },
+        {
+          title: "Nom de la base de données",
+          envVar: "MONGO_DB",
+          defaultValue: "mydb",
+          hideEchoBack: false,
+        },
+      ],
+    },
+    {
+      name: "sqlite",
+      label: "SQLite",
+      ormOptions: ["prisma", "sequelize"], // Choix des ORM supportés
+      required: [
+        {
+          title: "Chemin du fichier SQLite",
+          envVar: "SQLITE_PATH",
+          defaultValue: "./data/sqlite.db",
+          hideEchoBack: false,
+        },
+      ],
+    },
+    {
+      name: "firebase",
+      label: "Firebase Firestore",
+      ormOptions: ["firebase"], // Firebase n'a pas d'ORM traditionnel
+      required: [
+        {
+          title: "Chemin vers le fichier de configuration Firebase (JSON)",
+          envVar: "FIREBASE_CONFIG_PATH",
+          defaultValue: "./firebase-config.json",
+          hideEchoBack: false,
+        },
+      ],
+    },
+    {
+      name: "redis",
+      label: "Redis",
+      ormOptions: ["redis"], // Redis n'a pas d'ORM traditionnel
+      required: [
+        {
+          title: "URL de connexion Redis",
+          envVar: "REDIS_URL",
+          defaultValue: "redis://localhost:6379",
+          hideEchoBack: false,
+        },
+      ],
+    }, */
+  ];
+
+  const projectName = readline.question("Nom du projet: ");
+  // const databaseName = readline.question("Nom de la base de données: ");
+
+  let usedDB = readline.question(
+    `Quelle base de donnée voulez-vous utiliser ? (${dataBases
+      .map((db) => db.name)
+      .join(", ")}) : `,
+    { defaultInput: "postgresql" }
+  );
+
+  let selectedDB = dataBases.find(
+    (db) => db.name.toLowerCase() === usedDB.toLowerCase()
+  );
+
+  while (!selectedDB) {
+    console.log("❌ Base de données non reconnue.");
+
+    usedDB = readline.question(
+      `Quelle base de donnée voulez-vous utiliser ? (${dataBases
+        .map((db) => db.name)
+        .join(", ")}) : `
     );
-  }
 
-  toPersistence(dto: Create${capitalize(entity)}Dto): any {
-    return {
-      // ajoute ici les champs correspondants au DTO de création
-      // exemple:
-      // name: dto.name,
-      // description: dto.description,
-      // ...
-    };
+    selectedDB = dataBases.find(
+      (db) => db.name.toLowerCase() === usedDB.toLowerCase()
+    );
   }
 
-  toUpdatePersistence(dto: Update${capitalize(entity)}Dto): any {
-    const data: any = {};
-    // Logique conditionnelle pour ne mettre que les champs fournis
-    // exemple:
-    // if (dto.name) data.name = dto.name;
-    // if (dto.description) data.description = dto.description;
-    return data;
-  }
-}
-`
-
- // 📌 5. DTOs
-      const DtoFileContent = generateDto(entity);
-      await createFile({
-        path: `${entityPath}/application/dtos/${entity}.dto.ts`,
-        contente: `
-  // Importer les décorateurs nécessaires pour la validation et la documentation (Swagger)
-  // import { ApiProperty } from '@nestjs/swagger';
-  // import { IsString, IsOptional, IsInt, IsDate } from 'class-validator'; // Dépendances pour la validation
-
-  // Classe DTO pour la création de l'entité ${capitalize(entity)}
-  export class Create${capitalize(entity)}Dto {
-    // Exemple de propriété pour une chaîne de caractères
-    /* @ApiProperty({
-      description: 'Le nom complet de l\'utilisateur',
-      example: 'John Doe', // Exemple d'un nom complet
-    })
-    @IsString()
-    name: string; // Le nom de l'utilisateur, représenté par une chaîne de caractères */
-
-    // Exemple de propriété pour un nombre entier
-    /* @ApiProperty({
-      description: 'L\'âge de l\'utilisateur',
-      example: 25, // Exemple d'âge
-    })
-    @IsInt()
-    @IsOptional() // L'âge est optionnel lors de la création
-    age?: number; // Âge de l'utilisateur, un nombre entier */
-
-    // Exemple de propriété pour une date
-    /* @ApiProperty({
-      description: 'Date de naissance de l\'utilisateur',
-      example: '1996-05-20', // Exemple de date au format ISO
-    })
-    @IsDate()
-    birthdate: Date; // Date de naissance de l'utilisateur */
-  }
+  const dbConfig = {};
 
-  // Classe DTO pour la mise à jour de l'entité ${capitalize(entity)}
-  export class Update${capitalize(entity)}Dto {
-    // Exemple de propriété optionnelle pour un changement de nom
-    /* @ApiProperty({
-      description: 'Nom mis à jour de l\'utilisateur',
-      example: 'Jane Smith', // Exemple de nouveau nom
-    })
-    @IsString()
-    @IsOptional()
-    name?: string; // Nom mis à jour, chaîne de caractères optionnelle */
-
-    // Exemple de propriété optionnelle pour une mise à jour d'âge
-    /* @ApiProperty({
-      description: 'Âge mis à jour de l\'utilisateur',
-      example: 26, // Exemple d'âge mis à jour
-    })
-    @IsInt()
-    @IsOptional()
-    age?: number; // Âge mis à jour, nombre entier optionnel */
+  // Configuration de la base de données (champ utilisateur)
+  selectedDB.required.forEach((field) => {
+    const answer = readline.question(
+      `${field.title} (par défaut: ${field.defaultValue}) : `,
+      { hideEchoBack: field.hideEchoBack }
+    );
+    dbConfig[field.envVar] = answer || field.defaultValue;
+  });
+
+  // Ajout du choix de l'ORM dans la configuration
+  if (selectedDB.ormOptions && selectedDB.ormOptions.length > 0) {
+    const ormChoice = readline.question(
+      `Choisissez un ORM pour ${selectedDB.label} (${selectedDB.ormOptions.join(
+        ", "
+      )}): `
+    );
+    dbConfig.orm = ormChoice || selectedDB.ormOptions[0]; // Par défaut, choisir le premier ORM
   }
-`,
-      });
 
+  const useYarn = readline.keyInYNStrict("Utiliser Yarn ?");
+  const useDocker = readline.keyInYNStrict(
+    "Voulez-vous générer un fichier Docker?"
+  );
+  const useAuth = readline.keyInYNStrict(
+    "Voulez-vous ajouter une authentification JWT?"
+  );
+  const useSwagger = readline.keyInYNStrict("Voulez-vous installer Swagger?");
+  const packageManager = useYarn ? "yarn" : "npm";
+
+  // 🧱 Saisie des entités et champs
+  const entitiesData = {
+    entities: [],
+    relations: [],
+  };
+
+  if (useAuth) {
+    console.log("🔐 Auth activé : ajout automatique de l'entité 'User'");
+
+    entitiesData.entities.push({
+      name: "user",
+      fields: [
+        { name: "email", type: "string" },
+        { name: "password", type: "string" },
+        { name: "isActive", type: "boolean" },
+      ],
+    });
+  }
 
+  let addEntity = readline.keyInYNStrict(
+    "Voulez-vous ajouter une autre entité ?"
+  );
 
+  while (addEntity) {
+    const name = readline.question(`Nom de l'entité : `);
+    const fields = [];
 
+    while (true) {
+      const fname = readline.question(
+        `  ➤ Nom du champ (vide pour terminer) : `
+      );
+      if (!fname) break;
 
-`import { Injectable, NotFoundException } from '@nestjs/common';
-import { PrismaService } from 'src/prisma/prisma.service';
-import { Create${entityNameCapitalized}Dto,Update${entityNameCapitalized}Dto } from 'src/${entityNameLower}/application/dtos/${entityNameLower}.dto';
-import { I${entityNameCapitalized}Repository } from 'src/${entityNameLower}/application/interfaces/${entityNameLower}.repository.interface';
-import { ${entityNameCapitalized}Entity } from 'src/${entityNameLower}/domain/entities/${entityNameLower}.entity';
-import { ${entityNameCapitalized}Mapper } from 'src/${entityNameLower}/domain/mappers/${entityNameLower}.mapper';
+      const ftype = readline.question(
+        `    Type du champ "${fname}" (ex: string, number, boolean, Date, enum, etc.) : `
+      );
+      fields.push({ name: fname, type: ftype });
+    }
 
-@Injectable()
-export class ${entityNameCapitalized}Repository implements I${entityNameCapitalized}Repository {
-  constructor(
-    private readonly prisma: PrismaService,
-    private readonly mapper: ${entityNameCapitalized}Mapper,
-  ) {}
+    entitiesData.entities.push({ name, fields });
 
-  // create
-  async create(data: Create${entityNameCapitalized}Dto): Promise<${entityNameCapitalized}Entity> {
-    const toPersist = this.mapper.toPersistence(data);
-    const created = await this.prisma.${entityNameLower}.create({ data: toPersist });
-    return this.mapper.toDomain(created);
+    addEntity = readline.keyInYNStrict(
+      "Voulez-vous ajouter une autre entité ?"
+    );
   }
 
-  // find by id
-  async findById(id: string): Promise<${entityNameCapitalized}Entity> {
-    const record = await this.prisma.${entityNameLower}.findUnique({
-      where: { id },
-    });
+  // 🔗 Gestion des relations
+  const wantsRelation = readline.keyInYNStrict(
+    "Souhaites-tu ajouter des relations entre les entités ?"
+  );
+
+  if (wantsRelation) {
+    while (true) {
+      console.log("\n🧩 Entités disponibles :");
+      entitiesData.entities.forEach((ent, index) =>
+        console.log(`  [${index}] ${ent.name}`)
+      );
+
+      const fromIndex = parseInt(
+        readline.question("Depuis quelle entité ? (index) : "),
+        10
+      );
+      const toIndex = parseInt(
+        readline.question("Vers quelle entité ? (index) : "),
+        10
+      );
+      const relType = readline.question(
+        "Type de relation ? (1-1 / 1-n / n-n) : "
+      );
+
+      const from = entitiesData.entities[fromIndex];
+      const to = entitiesData.entities[toIndex];
+
+      if (!from || !to) {
+        console.log("❌ Indice invalide, réessaye !");
+        continue;
+      }
+
+      entitiesData.relations.push({
+        from: from.name,
+        to: to.name,
+        type: relType,
+      });
 
-    if (!record) {
-      throw new NotFoundException(\`${entityNameCapitalized}Entity with id \${id} not found\`);
+      const again = readline.keyInYNStrict("Ajouter une autre relation ?");
+      if (!again) break;
     }
+  }
 
-    return this.mapper.toDomain(record);
+  // Swagger (facultatif)
+  let swaggerInputs;
+  if (useSwagger) {
+    swaggerInputs = getUserInputsSwagger();
   }
 
-  // update
-  async update(id: string, data: Update${entityNameCapitalized}Dto): Promise<${entityNameCapitalized}Entity> {
-    const toUpdate = this.mapper.toUpdatePersistence(data);
-    const updated = await this.prisma.${entityNameLower}.update({
-      where: { id },
-      data: toUpdate,
-    });
+  return {
+    projectName: projectName,
+    useYarn: useYarn,
+    useDocker: useDocker,
+    useAuth: useAuth,
+    useSwagger: useSwagger,
+    swaggerInputs: swaggerInputs,
+    packageManager: packageManager,
+    entitiesData: entitiesData,
+    selectedDB: selectedDB.name,
+    dbConfig: dbConfig,
+  };
+}
 
-    return this.mapper.toDomain(updated);
-  }
+export function getUserInputsSwagger() {
+  console.log("\n🔹 Configuration de Swagger 🔹");
 
-  // find all
-  async findAll(): Promise<${entityNameCapitalized}Entity[]> {
-    const records = await this.prisma.${entityNameLower}.findMany();
-    return records.map(record => this.mapper.toDomain(record));
-  }
+  const title = readline.question("Titre de l'API ? (ex: Mon API) ", {
+    defaultInput: "Mon API",
+  });
 
-  // delete
-  async delete(id: string): Promise<void> {
-    await this.prisma.${entityNameLower}.delete({
-      where: { id },
-    });
-  }
+  const description = readline.question(
+    "Description de l'API ? (ex: API de gestion) ",
+    {
+      defaultInput: "API de gestion",
+    }
+  );
+
+  const version = readline.question("Version de l'API ? (ex: 1.0.0) ", {
+    defaultInput: "1.0.0",
+  });
+
+  const endpoint = readline.question("Endpoint Swagger (ex: api/docs) ", {
+    defaultInput: "api/docs",
+  });
+
+  return { title, description, version, endpoint };
 }
-`
-
-
-`
-/**
- * ${entityNameCapitalized}Controller gère les endpoints de l'API pour l'entité ${entityNameCapitalized}.
- * Il utilise les cas d'utilisation (Use Cases) pour orchestrer les différentes actions métiers liées à l'entité.
- * Ce contrôleur est responsable des actions HTTP telles que la création, la mise à jour, la récupération, et la suppression de ${entityNameCapitalized}.
- */
-
-import { Controller, Get, Post, Body, Param, Put, Delete, Injectable } from "@nestjs/common";
-import { ApiTags, ApiOperation } from '@nestjs/swagger';
-// Importation des cas d'utilisation (Use Cases) spécifiques à ${entityNameCapitalized}
-import { Create${entityNameCapitalized}UseCase } from "${entityPath}/application/use-cases/create-${entityNameLower}.use-case";
-import { Update${entityNameCapitalized}UseCase } from "${entityPath}/application/use-cases/update-${entityNameLower}.use-case";
-import { GetById${entityNameCapitalized}UseCase } from "${entityPath}/application/use-cases/getById-${entityNameLower}.use-case";
-import { GetAll${entityNameCapitalized}UseCase } from "${entityPath}/application/use-cases/getAll-${entityNameLower}.use-case";
-import { Delete${entityNameCapitalized}UseCase } from "${entityPath}/application/use-cases/delete-${entityNameLower}.use-case";
-// Importation des DTOs pour la validation et la transformation des données entrantes
-import { Create${entityNameCapitalized}Dto, Update${entityNameCapitalized}Dto } from 'src/${entityNameLower}/application/dtos/${entityNameLower}.dto';
-
-/**
- * Le contrôleur est annoté avec @ApiTags pour la documentation Swagger.
- * Il regroupe les opérations HTTP relatives à l'entité ${entityNameCapitalized}.
- */
-@Injectable()
-@ApiTags('${entityNameCapitalized}')
-@Controller('${entityNameLower}')
-export class ${entityNameCapitalized}Controller {
-  constructor(
-    private readonly createUseCase: Create${entityNameCapitalized}UseCase,
-    private readonly updateUseCase: Update${entityNameCapitalized}UseCase,
-    private readonly getByIdUseCase: GetById${entityNameCapitalized}UseCase,
-    private readonly getAllUseCase: GetAll${entityNameCapitalized}UseCase,
-    private readonly deleteUseCase: Delete${entityNameCapitalized}UseCase,
-  ) {}
-
-  // 📌 Créer un ${entityNameLower}
-  @Post()
-  @ApiOperation({ summary: 'Create a new ${entityNameLower}' })
-  async create${entityNameCapitalized}(
-    @Body() create${entityNameCapitalized}Dto: Create${entityNameCapitalized}Dto,
-  ) {
-    return this.createUseCase.execute(create${entityNameCapitalized}Dto);
+export async function createDirectory(directoryPath) {
+  try {
+    if (!fs.existsSync(directoryPath)) {
+      fs.mkdirSync(directoryPath, { recursive: true });
+      // console.log(`Dossier créé : ${directoryPath}`);
+    } else {
+      console.log(`Le dossier existe déjà : ${directoryPath}`);
+    }
+  } catch (error) {
+    console.error(
+      `Erreur lors de la création du dossier ${directoryPath}:`,
+      error
+    );
   }
+}
 
-  // 📌 Mettre à jour un ${entityNameLower}
-  @Put(':id')
-  @ApiOperation({ summary: 'Update a ${entityNameLower}' })
-  async update${entityNameCapitalized}(
-    @Param('id') id: string,
-    @Body() update${entityNameCapitalized}Dto: Update${entityNameCapitalized}Dto,
-  ) {
-    return this.updateUseCase.execute(id, update${entityNameCapitalized}Dto);
+export async function createFile(fileData) {
+  // console.log("creating file....");
+  try {
+    if (!fs.existsSync(fileData.path)) {
+      fs.writeFileSync(`${fileData.path}`, `${fileData.contente}`);
+    } else {
+      console.log(`Le fichier existe déjà : ${fileData.path}`);
+      fs.writeFileSync(`${fileData.path}`, `${fileData.contente}`);
+    }
+  } catch (error) {
+    console.error(
+      `Erreur lors de la création du fichier ${fileData.path}:`,
+      error
+    );
   }
+}
+
+export async function updateFile({ path, pattern, replacement }) {
+  try {
+    let mainTs = fs.readFileSync(path, "utf8");
+
+    // Si pattern est une string, on le convertit en RegExp
+    /*   const regexPattern =
+      typeof pattern === "string" ? new RegExp(pattern, "g") : pattern;
+
+    if (!regexPattern.test(mainTs)) {
+      console.warn(`Pattern not found in ${path}. No changes made.`);
+      return;
+    } */
 
-  // 📌 Récupérer un ${entityNameLower} par ID
-  @Get(':id')
-  @ApiOperation({ summary: 'Get a ${entityNameLower} by ID' })
-  async getById${entityNameCapitalized}(@Param('id') id: string) {
-    return this.getByIdUseCase.execute(id);
+    const updatedContent = mainTs.replace(pattern, replacement);
+    await fs.writeFileSync(path, updatedContent, "utf-8");
+    // console.log(`✅ Updated file: ${path}`);
+  } catch (error) {
+    console.error(`❌ Error updating file ${path}:`, error);
   }
+}
+
+export async function safeUpdateAppModule(entity) {
+  const filePath = "src/app.module.ts";
+  const moduleName = `${capitalize(entity)}Module`;
+
+  const content = await fs.readFileSync(filePath, "utf-8");
 
-  // 📌 Récupérer tous les ${entityNameLower}s
-  @Get()
-  @ApiOperation({ summary: 'Get all ${entityNameLower}s' })
-  async getAll${entityNameCapitalized}() {
-    return this.getAllUseCase.execute();
+  const importLine = `import {${moduleName}} from 'src/${entity}/${entity}.module';`;
+
+  const importPatern = `import { ConfigModule } from '@nestjs/config';`;
+
+  // Ajout de l'import s'il n'existe pas
+  if (!content.includes(importLine)) {
+    await updateFile({
+      path: filePath,
+      pattern: importPatern,
+      replacement: `${importPatern}\n${importLine}`,
+    });
   }
 
-  // 📌 Supprimer un ${entityNameLower}
-  @Delete(':id')
-  @ApiOperation({ summary: 'Delete a ${entityNameLower} by ID' })
-  async delete${entityNameCapitalized}(@Param('id') id: string) {
-    return this.deleteUseCase.execute(id);
+  // Regex qui capte le contenu de imports: [ ... ]
+  const importRegexPatern = `imports: [
+    ConfigModule.forRoot({
+      isGlobal: true, // Rendre ConfigModule accessible globalement
+      envFilePath: '.env', // Charger les variables d'environnement
+    }),`;
+  // const contentRegex = await fs.readFileSync(filePath, "utf-8");
+
+  if (!content.includes(moduleName)) {
+    await updateFile({
+      path: filePath,
+      pattern: importRegexPatern,
+      replacement: `${importRegexPatern}\n${moduleName},\n`,
+    });
   }
 }
-`
+
+export function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+export function decapitalize(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}

package/utils/configs/configureDocker.js

@@ -8,7 +8,7 @@ async function configureDocker(inputs) {
   const dockerfileContent = `FROM node:18\nWORKDIR /app\nCOPY . .\nRUN ${inputs.packageManager} install\nCMD ["${inputs.packageManager}", "run", "start"]`;
   fs.writeFileSync("Dockerfile", dockerfileContent);
 
-  const dockerComposeContent = `version: '3'\nservices:\n  db:\n    image: postgres\n    restart: always\n    environment:\n      POSTGRES_USER: ${inputs.dbUser}\n      POSTGRES_PASSWORD: ${inputs.dbPassword}\n      POSTGRES_DB: ${inputs.databaseName}\n    ports:\n      - "5432:5432"`;
+  const dockerComposeContent = `version: '3'\nservices:\n  db:\n    image: postgres\n    restart: always\n    environment:\n      POSTGRES_USER: ${inputs.dbConfig.POSTGRES_USER}\n      POSTGRES_PASSWORD: ${inputs.dbConfig.POSTGRES_PASSWORD}\n      POSTGRES_DB: ${inputs.dbConfig.POSTGRES_DB}\n    ports:\n      - "5432:5432"`;
   fs.writeFileSync("docker-compose.yml", dockerComposeContent);
 
   logSuccess("Docker Configuré avec succès");