@ifecodes/backend-template 1.1.1 → 1.1.5

package/README.md

@@ -113,18 +113,23 @@ my-backend/
 ```
 my-project/
 ├── shared/              # Shared utilities across services
-│   ├── config/         # Database, environment configs
+│   ├── config/         # Environment configs (db.ts only if auth enabled)
 │   └── utils/          # Logger, error handlers
 ├── services/
 │   ├── gateway/        # API Gateway (port 4000)
 │   ├── health-service/ # Health checks (port 4001)
-│   └── auth-service/   # Authentication (port 4002)
+│   └── auth-service/   # Authentication (port 4002, if enabled)
 ├── docker-compose.yml  # Docker setup (if selected)
 ├── pm2.config.js       # PM2 setup (if selected)
+├── .env                # Root environment variables
+├── .gitignore          # Git ignore (includes .env and node_modules)
+├── tsconfig.json       # Root TypeScript config with project references
 ├── .husky/             # Git hooks
 └── package.json        # Root package.json
 ```
 
+**Note**: Each microservice does NOT have its own `.env` file. Environment variables are managed at the root level through `docker-compose.yml` or `pm2.config.js`.
+
 ---
 
 ## ▶️ Running the Application
@@ -194,9 +199,9 @@ pm2 stop all
 
 ---
 
-## � TypeScript vs JavaScript
+## TypeScript vs JavaScript
 
-This CLI generates **TypeScript** projects by default but fully supports **JavaScript** through intelligent transformation:
+This CLI generates **TypeScript** projects by default but also includes explicit **JavaScript** templates. There is no fragile, on-the-fly TypeScript → JavaScript transform at runtime — the project templates include language-specific variants so the output is predictable and parseable in Node.js.
 
 ### TypeScript (Default)
 
@@ -207,12 +212,10 @@ This CLI generates **TypeScript** projects by default but fully supports **JavaS
 
 ### JavaScript
 
-- Automatically transpiled from TypeScript templates
-- Type annotations removed for cleaner code
-- Dependencies adjusted (no @types packages)
-- Same functionality, simpler syntax
-
-**Note**: When selecting JavaScript, the CLI transforms the TypeScript template on-the-fly, ensuring you get a production-ready JavaScript project with all the same features.
+- Pre-authored JavaScript (CommonJS) templates are included
+- No TypeScript annotations remain in generated `.js` files
+- DevDependencies that are TypeScript-only are omitted for JS projects
+- Same functionality with simpler runtime setup
 
 ---
 
@@ -246,10 +249,10 @@ This CLI generates **TypeScript** projects by default but fully supports **JavaS
 ### Monolith
 
 ```
-GET  /              - API information
-GET  /v1/health     - Health check
-POST /v1/auth/register - Register user (if auth enabled)
-POST /v1/auth/login    - Login user (if auth enabled)
+GET  /                  - API information
+GET  /api/v1/health     - Health check
+POST /api/v1/auth/register - Register user (if auth enabled)
+POST /api/v1/auth/login    - Login user (if auth enabled)
 ```
 
 ### Microservice
@@ -257,22 +260,40 @@ POST /v1/auth/login    - Login user (if auth enabled)
 All requests go through the API Gateway at `http://localhost:4000`
 
 ```
-GET  /health        - Health service
-POST /auth/register - Auth service (if enabled)
-POST /auth/login    - Auth service (if enabled)
+GET  /health            - Gateway health check
+GET  /api/v1/health     - Health service check
+POST /api/v1/auth/register - Auth service (if enabled)
+POST /api/v1/auth/login    - Auth service (if enabled)
 ```
 
 ---
 
 ## 🔧 Environment Variables
 
-### Basic Setup
+### Monolith
 
 ```env
 PORT=4000
 NODE_ENV=development
 ```
 
+### Microservice (Root .env)
+
+```env
+NODE_ENV=development
+
+# Gateway Service
+GATEWAY_PORT=4000
+
+# Health Service  
+HEALTH_SERVICE_PORT=4001
+
+# Auth Service (if enabled)
+AUTH_SERVICE_PORT=4002
+```
+
+**Note**: Microservices use environment variables from `docker-compose.yml` or `pm2.config.js`. Individual services don't have `.env` files.
+
 ### With CORS
 
 ```env

package/bin/cli.js

@@ -7,11 +7,12 @@ import pc from "picocolors";
 import { getProjectConfig } from "./lib/prompts.js";
 import { setupService } from "./lib/service-setup.js";
 import { generateReadme } from "./lib/readme-generator.js";
-import { stripTypeScript, getJavaScriptScripts, getJavaScriptDependencies } from "./lib/ts-to-js.js";
+// No TS->JS transform: templates contain language-specific folders (base/js, base/ts)
 import {
   generateDockerCompose,
   generatePm2Config,
   copyDockerfile,
+  copyDockerignore,
 } from "./lib/microservice-config.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -26,7 +27,10 @@ const {
   isInMicroserviceProject,
 } = config;
 
-const base = path.join(__dirname, "../template/base");
+const baseRoot = (config.language === "javascript")
+  ? path.join(__dirname, "../template/base/js")
+  : path.join(__dirname, "../template/base/ts");
+const base = baseRoot;
 
 // Determine which services to create
 const servicesToCreate = [];
@@ -57,105 +61,25 @@ if (!isInMicroserviceProject && config.projectType === "microservice") {
   }
   fs.cpSync(base, target, { recursive: true });
   
-  // Transform to JavaScript if selected
-  if (config.language === "javascript") {
-    // console.log("\n🔄 Converting TypeScript to JavaScript...\n");
-    console.log(`\n${pc.cyan("⚙️  Setting up JavaScript project...")}\n`);
-    transformToJavaScript(target);
-  }
-} else if (isInMicroserviceProject) {
-  console.log(`\n${pc.cyan("🏗️  Adding service:")} ${pc.bold(servicesToCreate[0])}...\n`);
-}
-
-// Helper function to transform TypeScript project to JavaScript
-function transformToJavaScript(projectRoot) {
-  // Recursively find and transform all .ts files
-  function transformDirectory(dir) {
-    const items = fs.readdirSync(dir);
+  // Remove db.ts from config if auth is not enabled
+  if (!config.auth) {
+    const dbPath = path.join(target, "src/config/db.ts");
+    if (fs.existsSync(dbPath)) {
+      fs.rmSync(dbPath);
+    }
     
-    for (const item of items) {
-      const fullPath = path.join(dir, item);
-      const stat = fs.statSync(fullPath);
-      
-      if (stat.isDirectory()) {
-        // Skip node_modules and dist
-        if (item !== 'node_modules' && item !== 'dist') {
-          transformDirectory(fullPath);
-        }
-      } else if (item.endsWith('.ts') && !item.endsWith('.d.ts')) {
-        // Transform TypeScript file to JavaScript
-        const content = fs.readFileSync(fullPath, 'utf8');
-        const jsContent = stripTypeScript(content);
-        const jsPath = fullPath.replace(/\.ts$/, '.js');
-        
-        fs.writeFileSync(jsPath, jsContent);
-        fs.unlinkSync(fullPath); // Remove original .ts file
-      }
+    // Update index.ts to not export connectDB
+    const indexPath = path.join(target, "src/config/index.ts");
+    if (fs.existsSync(indexPath)) {
+      let indexContent = fs.readFileSync(indexPath, "utf8");
+      indexContent = indexContent.replace('export { connectDB } from "./db";\n', '');
+      fs.writeFileSync(indexPath, indexContent);
     }
   }
   
-  transformDirectory(path.join(projectRoot, 'src'));
-  
-  // Remove TypeScript config file
-  const tsconfigPath = path.join(projectRoot, 'tsconfig.json');
-  if (fs.existsSync(tsconfigPath)) {
-    fs.unlinkSync(tsconfigPath);
-  }
-  
-  // Remove .eslintrc.json and replace with JS version
-  const eslintrcPath = path.join(projectRoot, '.eslintrc.json');
-  if (fs.existsSync(eslintrcPath)) {
-    fs.unlinkSync(eslintrcPath);
-  }
-  
-  // Update package.json
-  const packageJsonPath = path.join(projectRoot, 'package.json');
-  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-  
-  // Update scripts
-  packageJson.scripts = {
-    ...packageJson.scripts,
-    ...getJavaScriptScripts()
-  };
-  
-  // Update type
-  packageJson.type = "module";
-  
-  // Remove main field
-  delete packageJson.main;
-  
-  // Update dependencies
-  const { dependencies, devDependencies } = getJavaScriptDependencies(
-    packageJson.dependencies,
-    packageJson.devDependencies
-  );
-  
-  packageJson.dependencies = dependencies;
-  packageJson.devDependencies = devDependencies;
-  
-  // Remove _moduleAliases (not needed for ES modules with import maps)
-  delete packageJson._moduleAliases;
-  
-  fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
-  
-  // Create simple .eslintrc.json for JavaScript
-  const eslintConfig = {
-    env: {
-      node: true,
-      es2021: true
-    },
-    extends: ["eslint:recommended", "prettier"],
-    parserOptions: {
-      ecmaVersion: "latest",
-      sourceType: "module"
-    },
-    rules: {}
-  };
-  
-  fs.writeFileSync(
-    path.join(projectRoot, '.eslintrc.json'),
-    JSON.stringify(eslintConfig, null, 2) + '\n'
-  );
+  // No TypeScript-to-JavaScript conversion — templates include language-specific variants
+} else if (isInMicroserviceProject) {
+  console.log(`\n${pc.cyan("🏗️  Adding service:")} ${pc.bold(servicesToCreate[0])}...\n`);
 }
 
 // Process services
@@ -176,11 +100,53 @@ if (isInMicroserviceProject || config.projectType === "microservice") {
       fs.cpSync(baseConfigDir, sharedConfigDir, { recursive: true });
       fs.cpSync(baseUtilsDir, sharedUtilsDir, { recursive: true });
 
+      // Remove db.ts from shared config if auth is not enabled
+      if (!config.auth) {
+        const sharedDbPath = path.join(sharedConfigDir, "db.ts");
+        if (fs.existsSync(sharedDbPath)) {
+          fs.rmSync(sharedDbPath);
+        }
+        
+        // Update index.ts to not export connectDB
+        const sharedIndexPath = path.join(sharedConfigDir, "index.ts");
+        if (fs.existsSync(sharedIndexPath)) {
+          let indexContent = fs.readFileSync(sharedIndexPath, "utf8");
+          indexContent = indexContent.replace('export { connectDB } from "./db";\n', '');
+          fs.writeFileSync(sharedIndexPath, indexContent);
+        }
+      }
+
+      // Update shared env.ts to include all service port environment variables
+      const sharedEnvPath = path.join(sharedConfigDir, "env.ts");
+      if (fs.existsSync(sharedEnvPath)) {
+        let envContent = fs.readFileSync(sharedEnvPath, "utf8");
+        
+        // Build port environment variables for all services
+        const allServices = ["gateway", "health-service"];
+        if (config.auth) allServices.push("auth-service");
+        
+        const portEnvVars = allServices.map((service) => {
+          const isGateway = service === "gateway";
+          const envVarName = `${service.toUpperCase().replace(/-/g, "_")}_PORT`;
+          // Don't add ! for JavaScript projects - it will cause syntax errors
+          const assertion = config.language === "javascript" ? "" : "!";
+          return `  ${envVarName}: process.env.${envVarName}${assertion},`;
+        }).join("\n");
+        
+        // Replace PORT with service-specific ports
+        envContent = envContent.replace(
+          "  PORT: process.env.PORT!,",
+          portEnvVars
+        );
+        
+        fs.writeFileSync(sharedEnvPath, envContent);
+      }
+
       // Create shared package.json
       const sharedPackageJson = {
         name: "@shared/common",
         version: "1.0.0",
-        type: "module",
+        type: "commonjs",
         exports: {
           "./config/*": "./config/*",
           "./utils/*": "./utils/*",
@@ -204,6 +170,12 @@ if (isInMicroserviceProject || config.projectType === "microservice") {
     console.log(`\n🔨 Setting up ${serviceName}...`);
     fs.cpSync(base, serviceRoot, { recursive: true });
 
+    // Remove .env and .env.example from microservices (environment variables come from docker-compose/pm2)
+    const envPath = path.join(serviceRoot, ".env");
+    const envExamplePath = path.join(serviceRoot, ".env.example");
+    if (fs.existsSync(envPath)) fs.rmSync(envPath);
+    if (fs.existsSync(envExamplePath)) fs.rmSync(envExamplePath);
+
     // Remove config and utils from service (they'll use shared) - except gateway handles it differently
     if (serviceName !== "gateway") {
       const serviceConfigDir = path.join(serviceRoot, "src", "config");
@@ -223,10 +195,10 @@ if (isInMicroserviceProject || config.projectType === "microservice") {
         .filter((f) => fs.statSync(path.join(servicesDir, f)).isDirectory())
     : servicesToCreate;
 
-  // Track if all installs succeeded for Husky setup
-  let allInstallsSucceeded = true;
-
-  // Now setup each service with knowledge of all services
+  // Step 1: Setup all service files first (without installing dependencies)
+  console.log(pc.cyan("\n⚙️  Setting up service files...\n"));
+  const serviceConfigs = [];
+  
   for (const serviceName of servicesToCreate) {
     const serviceRoot = path.join(target, "services", serviceName);
     const shouldIncludeAuth = isInMicroserviceProject
@@ -237,19 +209,22 @@ if (isInMicroserviceProject || config.projectType === "microservice") {
       serviceName,
       serviceRoot,
       shouldIncludeAuth,
-      allServices
+      allServices,
+      true // Skip install for now
     );
-    if (!result.installSucceeded) {
-      allInstallsSucceeded = false;
-    }
+    serviceConfigs.push({
+      serviceName,
+      serviceRoot,
+      deps: result.deps,
+      devDeps: result.devDeps
+    });
   }
 
-  // Store for later use
-  config.allInstallsSucceeded = allInstallsSucceeded;
-
+  // Step 2: Generate docker-compose/pm2 config and root files
   if (mode === "docker") {
     generateDockerCompose(target, allServices);
     copyDockerfile(target, servicesToCreate);
+    copyDockerignore(target, servicesToCreate);
   } else {
     generatePm2Config(target, allServices);
   }
@@ -273,24 +248,14 @@ if (isInMicroserviceProject || config.projectType === "microservice") {
       JSON.stringify(rootPackageJson, null, 2) + "\n"
     );
   }
-} else {
-  const result = await setupService(config, null, target, true);
-  config.installSucceeded = result.installSucceeded;
-}
 
-// Generate README.md
-if (!isInMicroserviceProject) {
-  console.log(`\n${pc.cyan("📝 Generating README.md...")}\n`);
-  const readmeContent = generateReadme(config);
-  fs.writeFileSync(path.join(target, "README.md"), readmeContent);
-  
-  // Rename gitignore to .gitignore (npm doesn't publish .gitignore files)
-  if (config.projectType === "microservice") {
-    const servicesDir = path.join(target, "services");
-    const allServices = fs.readdirSync(servicesDir).filter((f) => 
-      fs.statSync(path.join(servicesDir, f)).isDirectory()
-    );
+  // Step 3: Generate README and create root configuration files
+  if (!isInMicroserviceProject) {
+    console.log(`\n${pc.cyan("📝 Generating README.md...")}\n`);
+    const readmeContent = generateReadme(config);
+    fs.writeFileSync(path.join(target, "README.md"), readmeContent);
     
+    // Rename gitignore to .gitignore (npm doesn't publish .gitignore files)
     for (const service of allServices) {
       const gitignorePath = path.join(servicesDir, service, "gitignore");
       const dotGitignorePath = path.join(servicesDir, service, ".gitignore");
@@ -298,35 +263,126 @@ if (!isInMicroserviceProject) {
         fs.renameSync(gitignorePath, dotGitignorePath);
       }
     }
-  } else {
-    const gitignorePath = path.join(target, "gitignore");
-    const dotGitignorePath = path.join(target, ".gitignore");
-    if (fs.existsSync(gitignorePath)) {
-      fs.renameSync(gitignorePath, dotGitignorePath);
-    }
-  }
-  
-  // Generate .env from .env.example for each service or root
-  console.log(`${pc.cyan("📄 Setting up environment files...")}\n`);
-  if (config.projectType === "microservice") {
-    const servicesDir = path.join(target, "services");
-    const allServices = fs.readdirSync(servicesDir).filter((f) => 
-      fs.statSync(path.join(servicesDir, f)).isDirectory()
+    
+    // Create root .gitignore for microservices
+    const rootGitignoreContent = `.env\nnode_modules\n`;
+    fs.writeFileSync(path.join(target, ".gitignore"), rootGitignoreContent);
+
+    // Create root .env and .env.example for microservices
+    let rootENVContent = `# Environment Configuration\nNODE_ENV=development\n\n`;
+    
+    // Add port configuration for each service
+    allServices.forEach((service, index) => {
+      const isGateway = service === "gateway";
+      const port = isGateway ? 4000 : 4001 + allServices.filter((s, i) => s !== "gateway" && i < index).length;
+      const envVarName = `${service.toUpperCase().replace(/-/g, "_")}_PORT`;
+      const serviceName = service.split("-").map(word => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+      rootENVContent += `# ${serviceName}\n${envVarName}=${port}\n\n`;
+    });
+    
+    fs.writeFileSync(path.join(target, ".env"), rootENVContent);
+    fs.writeFileSync(path.join(target, ".env.example"), rootENVContent);
+
+    // Create root tsconfig.json for microservices workspace
+    const rootTsConfigContent = {
+      "compilerOptions": {
+        "target": "ES2020",
+        "module": "CommonJS",
+        "lib": ["ES2020"],
+        "moduleResolution": "node",
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "strict": true,
+        "baseUrl": ".",
+        "paths": {
+          "@/*": ["./*"]
+        }
+      },
+      "include": [],
+      "references": allServices.map(service => ({
+        "path": `./services/${service}`
+      }))
+    };
+    fs.writeFileSync(
+      path.join(target, "tsconfig.json"),
+      JSON.stringify(rootTsConfigContent, null, 2) + "\n"
     );
+  }
+
+  // Step 5: Install dependencies for all services
+
+  console.log(pc.cyan("\n📦 Installing dependencies for all services...\n"));
+  let allInstallsSucceeded = true;
+
+  for (const { serviceName, serviceRoot, deps, devDeps } of serviceConfigs) {
+    console.log(pc.cyan(`\n📦 Installing dependencies for ${serviceName}...\n`));
     
-    for (const service of allServices) {
-      const envExamplePath = path.join(servicesDir, service, ".env.example");
-      const envPath = path.join(servicesDir, service, ".env");
-      if (fs.existsSync(envExamplePath) && !fs.existsSync(envPath)) {
-        fs.copyFileSync(envExamplePath, envPath);
+    try {
+      if (deps.length) {
+        execSync(`npm install ${deps.join(" ")}`, {
+          cwd: serviceRoot,
+          stdio: "inherit",
+        });
       }
+      if (devDeps.length) {
+        execSync(`npm install -D ${devDeps.join(" ")}`, {
+          cwd: serviceRoot,
+          stdio: "inherit",
+        });
+      }
+      execSync("npm install", { cwd: serviceRoot, stdio: "inherit" });
+
+      // Run format after successful install
+      console.log(pc.cyan("\n🎨 Formatting code...\n"));
+      try {
+        execSync("npm run format", { cwd: serviceRoot, stdio: "inherit" });
+      } catch (formatError) {
+        console.warn(
+          pc.yellow(
+            "⚠️  Warning: Code formatting failed. You can run it manually later with: npm run format\n",
+          ),
+        );
+      }
+    } catch (error) {
+      allInstallsSucceeded = false;
+      console.error(
+        pc.red(`\n❌ Failed to install dependencies for ${serviceName}`),
+      );
+      console.error(pc.dim(`\nYou can install them later by running:`));
+      console.error(pc.cyan(`   cd services/${serviceName} && npm install\n`));
     }
-  } else {
-    const envExamplePath = path.join(target, ".env.example");
-    const envPath = path.join(target, ".env");
-    if (fs.existsSync(envExamplePath) && !fs.existsSync(envPath)) {
-      fs.copyFileSync(envExamplePath, envPath);
+  }
+
+  // Store for later use
+  config.allInstallsSucceeded = allInstallsSucceeded;
+} else {
+  const result = await setupService(config, null, target, true);
+  config.installSucceeded = result.installSucceeded;
+}
+
+// Generate README.md for monolith (microservices already done above)
+if (!isInMicroserviceProject && config.projectType === "monolith") {
+  console.log(`\n${pc.cyan("📝 Generating README.md...")}\n`);
+  const readmeContent = generateReadme(config);
+  fs.writeFileSync(path.join(target, "README.md"), readmeContent);
+  
+  // Rename gitignore to .gitignore (npm doesn't publish .gitignore files)
+  const gitignorePath = path.join(target, "gitignore");
+  const dotGitignorePath = path.join(target, ".gitignore");
+  if (fs.existsSync(gitignorePath)) {
+    fs.renameSync(gitignorePath, dotGitignorePath);
+  }
+  
+  // Generate .env from .env.example for monolith only
+  console.log(`${pc.cyan("📄 Setting up environment files...")}\n`);
+  try {
+    const rootEnvExamplePath = path.join(target, ".env.example");
+    const rootEnvPath = path.join(target, ".env");
+    if (fs.existsSync(rootEnvExamplePath) && !fs.existsSync(rootEnvPath)) {
+      fs.copyFileSync(rootEnvExamplePath, rootEnvPath);
     }
+  } catch (err) {
+    // Non-fatal; proceed even if we fail to write env files
   }
 }
 

package/bin/lib/microservice-config.js

@@ -6,38 +6,63 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 export const generateDockerCompose = (target, allServices) => {
   const dockerCompose = {
-    version: "3.8",
     services: {},
   };
 
+  // Build environment variables map for all services
+  const allServicePorts = allServices.map((service, index) => {
+    const isGateway = service === "gateway";
+    const port = isGateway ? 4000 : 4001 + allServices.filter((s, i) => s !== "gateway" && i < index).length;
+    const envVarName = `${service.toUpperCase().replace(/-/g, "_")}_PORT`;
+    return { service, port, envVarName };
+  });
+
   for (const serviceName of allServices) {
     // Gateway runs on 4000, other services start from 4001
-    const isGateway = serviceName === "gateway";
-    const serviceIndex = allServices.indexOf(serviceName);
-    const port = isGateway ? 4000 : 4001 + allServices.filter((s, i) => s !== "gateway" && i < serviceIndex).length;
+    const serviceInfo = allServicePorts.find(s => s.service === serviceName);
+    const port = serviceInfo.port;
+    const envVarName = serviceInfo.envVarName;
+    
+    // Build environment variables array - include all service ports
+    const environmentVars = [
+      `NODE_ENV=\${NODE_ENV:-development}`,
+      ...allServicePorts.map(s => `${s.envVarName}=\${${s.envVarName}:-${s.port}}`)
+    ];
     
     dockerCompose.services[serviceName] = {
-      build: `./services/${serviceName}`,
+      build: {
+        context: `./services/${serviceName}`,
+        dockerfile: "Dockerfile"
+      },
+      image: `${serviceName}:latest`,
+      container_name: serviceName,
       ports: [
-        `\${${serviceName
-          .toUpperCase()
-          .replace(/-/g, "_")}_PORT:-${port}}:${isGateway ? 4000 : 4000}`,
+        `\${${envVarName}:-${port}}:\${${envVarName}:-${port}}`,
+      ],
+      environment: environmentVars,
+      volumes: [
+        `./services/${serviceName}:/app`,
+        `./shared:/app/shared`,
+        `/app/node_modules`
       ],
-      environment: [`NODE_ENV=\${NODE_ENV:-development}`],
-      volumes: [`./services/${serviceName}:/app`, `/app/node_modules`],
     };
   }
 
   fs.writeFileSync(
     path.join(target, "docker-compose.yml"),
-    `version: "${dockerCompose.version}"\nservices:\n` +
+    `services:\n` +
       Object.entries(dockerCompose.services)
         .map(
           ([name, config]) =>
             `  ${name}:\n` +
-            `    build: ${config.build}\n` +
+            `    build:\n` +
+            `      context: ${config.build.context}\n` +
+            `      dockerfile: ${config.build.dockerfile}\n` +
+            `    image: ${config.image}\n` +
+            `    container_name: ${config.container_name}\n` +
             `    ports:\n      - "${config.ports[0]}"\n` +
-            `    environment:\n      - ${config.environment[0]}\n` +
+            `    environment:\n` +
+            config.environment.map((e) => `      - ${e}`).join("\n") + "\n" +
             `    volumes:\n` +
             config.volumes.map((v) => `      - ${v}`).join("\n")
         )
@@ -87,3 +112,22 @@ export const copyDockerfile = (target, servicesToCreate) => {
     }
   }
 };
+
+export const copyDockerignore = (target, servicesToCreate) => {
+  const dockerignorePath = path.join(
+    __dirname,
+    "../../template/microservice/docker/.dockerignore"
+  );
+  
+  for (const serviceName of servicesToCreate) {
+    const serviceDockerignore = path.join(
+      target,
+      "services",
+      serviceName,
+      ".dockerignore"
+    );
+    if (!fs.existsSync(serviceDockerignore)) {
+      fs.copyFileSync(dockerignorePath, serviceDockerignore);
+    }
+  }
+};