@saulpaulus17/node-module-generator 2.0.2 → 2.0.5

package/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,38 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Desktop (please complete the following information):**
+ - OS: [e.g. iOS]
+ - Browser [e.g. chrome, safari]
+ - Version [e.g. 22]
+
+**Smartphone (please complete the following information):**
+ - Device: [e.g. iPhone6]
+ - OS: [e.g. iOS8.1]
+ - Browser [e.g. stock browser, safari]
+ - Version [e.g. 22]
+
+**Additional context**
+Add any other context about the problem here.

package/.github/ISSUE_TEMPLATE/custom.md

@@ -0,0 +1,10 @@
+---
+name: Custom issue template
+about: Describe this issue template's purpose here.
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+

package/.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

package/CONTRIBUTING.md

@@ -0,0 +1,110 @@
+# Contributing to Node Module Generator
+
+First off, thank you for considering contributing to **Node Module Generator (NMG)**! It is people like you who make this tool a better resource for the entire Node.js community.
+
+Please take a moment to review this document to understand the contribution process.
+
+---
+
+## ⚖️ Code of Conduct
+
+By participating in this project, you agree to abide by our Code of Conduct. We expect all contributors to maintain a respectful, inclusive, and professional environment.
+
+---
+
+## 🛠️ Getting Started
+
+### Prerequisites
+- **Node.js**: v18.0.0 or higher
+- **NPM**, **Yarn**, or **PNPM**
+
+### Development Setup
+1. Fork the repository on GitHub.
+2. Clone your fork locally:
+   ```bash
+   git clone https://github.com/YOUR_USERNAME/node-module-generator.git
+   cd node-module-generator
+   ```
+3. Install dependencies:
+   ```bash
+   npm install
+   ```
+
+### 🧪 Local Testing
+To test your changes locally, you can run the CLI directly from the source:
+```bash
+node bin/cli.js <command> <name>
+```
+
+Alternatively, link it globally for local development:
+```bash
+npm link
+# Now you can use 'nmg' command locally
+```
+
+---
+
+## 📈 How to Contribute
+
+### Reporting Bugs
+- Check the **Issues** tab to see if the bug has already been reported.
+- If not, open a new issue. Include a clear title, a description of the bug, steps to reproduce, and the expected vs. actual behavior.
+
+### Proposing Features
+- Open an issue titled `feat: <Description>` to discuss the proposal before starting any implementation.
+
+### Pull Request Process
+1. Create a new branch for your feature or fix:
+   ```bash
+   git checkout -b feat/your-feature-name
+   # OR
+   git checkout -b fix/your-bug-name
+   ```
+2. Implement your changes. Ensure you adhere to **Clean Architecture** patterns.
+3. **Write Tests**: If you add a new feature or fix a bug, please include a test case.
+4. Run the full test suite:
+   ```bash
+   npm test
+   ```
+5. Commit your changes using **Conventional Commits** (see below).
+6. Push to your fork and submit a Pull Request to the `main` branch.
+
+---
+
+## 📝 Coding Standards
+
+- **Clean Architecture**: Maintain strict separation between Domain, Application, Infrastructure, and Interface layers.
+- **ESM/CJS**: New modules should follow the latest ESM templates.
+- **DRY & SOLID**: Write clean, modular, and reusable code.
+
+---
+
+## 🏷️ Commit Message Guidelines
+
+We follow the [Conventional Commits](https://www.conventionalcommits.org/) specification for our commit messages:
+
+- `feat:`: A new feature for the user.
+- `fix:`: A bug fix for the user.
+- `docs:`: Documentation only changes.
+- `refactor:`: A code change that neither fixes a bug nor adds a feature.
+- `test:`: Adding missing tests or correcting existing tests.
+- `chore:`: Changes to the build process or auxiliary tools.
+
+Example:
+```text
+feat(generator): add support for Zod schemas
+```
+
+---
+
+## ✅ Pull Request Checklist
+
+Before submitting your PR, please ensure:
+1. [ ] The code follows the project's architecture and style.
+2. [ ] All tests pass locally (`npm test`).
+3. [ ] All status checks on GitHub (CI) pass.
+4. [ ] Documentation is updated if necessary.
+5. [ ] Commit messages follow the Conventional Commits standard.
+
+---
+Thank you for your contribution! 🚀

package/DOCS_STEPS.md

@@ -0,0 +1,40 @@
+# Langkah-langkah Setelah Generate Modul Baru
+
+Setelah menjalankan perintah `nmg module <name>`, ikuti langkah-langkah berikut untuk mengintegrasikan modul ke dalam proyek Node.js Anda:
+
+## 1. Registrasi di Awilix Container (`src/container.js`)
+
+Buka file `src/container.js` dan tambahkan registrasi untuk repository jika Anda ingin menggunakan alias spesifik:
+
+```javascript
+import { asFunction } from 'awilix';
+
+// ... di dalam container.register({ ... })
+container.register({
+  // Contoh alias: [module]Repository -> prisma[Module]Repository
+  authRepository: asFunction(({ prismaAuthRepository }) => prismaAuthRepository).scoped(),
+});
+```
+
+*Catatan: Secara default, generator Awilix biasanya mengauto-load file. Pastikan loader Anda dikonfigurasi untuk memuat folder `usecases`, `repositories`, `controllers`, dan `routes`.*
+
+## 2. Registrasi Route di Express (`src/app.js`)
+
+Buka file `src/app.js` dan daftarkan router dari modul yang baru dibuat:
+
+```javascript
+// ...
+app.use('/api/v1/auth', container.resolve('authRoutes'));
+// ...
+```
+
+## 3. Implementasi Detail Bisnis
+*   **Domain**: Tentukan skema data di `domain/entities`.
+*   **Repository Interface**: Tambahkan method yang dibutuhkan di `domain/repositories`.
+*   **Repository Implementation**: Implementasikan query database (Prisma) di `infrastructure/repositories`.
+*   **UseCase**: Tulis logika bisnis utama di `application/usecases`.
+*   **Controller**: Tangani input request dan panggil UseCase di `interfaces/controllers`.
+*   **Routes**: Definisikan endpoint HTTP di `interfaces/routes`.
+
+---
+*Generated by node-module-generator*

package/README.md

@@ -1,103 +1,166 @@
 <div align="center">
-  <h1>🚀 Node Module Generator</h1>
-  <p>A robust CLI tool for scaffolding Express.js projects using Clean Architecture & Dependency Injection.</p>
+  <img src="https://raw.githubusercontent.com/saul-paulus/node-module-generator/main/assets/banner.png" alt="Node Module Generator Banner" width="600" style="max-width: 100%;" />
+  <h1>🚀 Node Module Generator (NMG)</h1>
+  <p><strong>The ultimate CLI companion for rapid, enterprise-grade Node.js scaffolding.</strong></p>
   <p>
     <a href="https://github.com/saul-paulus/node-module-generator/actions/workflows/ci.yml">
       <img src="https://github.com/saul-paulus/node-module-generator/actions/workflows/ci.yml/badge.svg" alt="CI Status">
     </a>
+    <a href="https://www.npmjs.com/package/@saulpaulus17/node-module-generator">
+      <img src="https://img.shields.io/npm/v/@saulpaulus17/node-module-generator.svg?logo=npm&logoColor=white" alt="NPM Version" />
+    </a>
+    <a href="https://www.npmjs.com/package/@saulpaulus17/node-module-generator">
+      <img src="https://img.shields.io/npm/dt/@saulpaulus17/node-module-generator.svg?logo=npm&logoColor=white" alt="NPM Downloads" />
+    </a>
+    <a href="https://github.com/saul-paulus/node-module-generator/blob/main/LICENSE">
+      <img src="https://img.shields.io/npm/l/@saulpaulus17/node-module-generator.svg" alt="License" />
+    </a>
   </p>
 </div>
 
 ---
 
-## 📖 Overview
+## 🏛️ Architecture Overview
+
+Node Module Generator (NMG) enforces **Clean Architecture** principles to ensure your backend remains scalable, testable, and decoupled. It is purpose-built for high-performance **Express.js** environments using **Awilix** for Dependency Injection.
+
+### Layered Structure
+```mermaid
+graph TD
+    UI[Interfaces Layer: Controllers & Routes] --> APP[Application Layer: Use Cases & DTOs]
+    APP --> DOM[Domain Layer: Entities & Repository Interfaces]
+    INF[Infrastructure Layer: Repository Impl & External Services] --> DOM
+    
+    subgraph "Inner Layers"
+    DOM
+    APP
+    end
+    
+    subgraph "Outer Layers"
+    UI
+    INF
+    end
+```
 
-**Node Module Generator** provides a world-class Developer Experience (DX) equivalent to the robust CLIs found in ecosystems like NestJS or Angular, but designed specifically for pure Node.js environments utilizing **Express.js** and **Clean Architecture**.
+---
 
-It instantly scaffolds fully-tested, decoupled, and highly cohesive module structures with built-in Dependency Injection using **Awilix**.
+## 🔥 Key Features
 
-## ✨ Features
+- 💎 **Clean Architecture by Design**: Strict separation into Domain, Application, Infrastructure, and Interface layers.
+- 💉 **Native Dependency Injection**: Fully pre-configured for **Awilix**, providing seamless DI management.
+- 🧪 **Test-Ready Scaffolding**: Automatically generates **Jest** test suites for Controllers and Use Cases.
+- 🚀 **Modern Tooling**: Native support for **ES Modules (ESM)**, **Prisma ORM**, and **Joi/Zod** DTO patterns.
+- 🤖 **Granular Control**: Generate full modules or individual components (UseCases, Repos, DTOs) without disrupting existing code.
 
-- 🏗️ **Clean Architecture by Default**: Automatically separates concerns into Domain, Application, Infrastructure, and Interface layers.
-- 💉 **Dependency Injection Ready**: Auto-generates Awilix configurations mapped correctly across use cases, controllers, and repositories.
-- 🧪 **Test-Driven Design**: Scaffolds adjoining `*.test.js` files containing boilerplates for Jest to promote TDD.
-- 🤖 **Continuous Integration**: Codebase natively incorporates GitHub Actions for automated unit testing checks.
-- 🧩 **Granular Scaffolding**: Generate specific components (UseCases, Repositories, DTOs) dynamically on demand without overriding existing folders!
+---
 
 ## 📦 Installation
 
-To use this CLI tool locally or globally on your machine, you can install it directly from NPM.
+### Prerequisites
+- **Node.js**: v18.0.0 or higher (LTS recommended)
+- **NPM**, **Yarn**, or **PNPM**
+
+### Global Installation (Recommended)
+Install NMG globally to access the command from any project.
 
 ```bash
-# Install globally via NPM
 npm install -g @saulpaulus17/node-module-generator
 ```
 
-## 🚀 Usage
+### Direct Execution
+Run it on-the-fly without a permanent installation:
 
-Once installed globally, you can execute the CLI commands from any of your Node.js project directories using the `nmg` command keyword.
+```bash
+npx @saulpaulus17/node-module-generator <command> <name>
+```
+
+---
 
-### Granular CLI Commands
-Scaffold specifically what you need, exactly how you do it in NestJS:
+## 🚀 Detailed Usage
+
+### 1. Generating a Full Module
+Scaffolds a complete standard architecture with all 4 layers and initial unit tests.
 
 ```bash
-# 1. Scaffolds a new module architecture and empty DI registry
-nmg module product
+nmg module Auth
+```
 
-# 2. Creates a specific Use Case and its Test inside an existing module
-nmg usecase updateProduct --module=product
+### 2. Generating Individual Components
+Quickly add specific components to an existing module structure.
 
-# 3. Creates Domain Entity and Repository Interfaces/Implementations
-nmg repository product
+```bash
+# Add a new UseCase (e.g., login) to the Auth module
+nmg usecase login --module=Auth
 
-# 4. Scaffolds a DTO validation schema
-nmg dto getProduct --module=product
+# Add a Repository Interface and Implementation (Prisma)
+nmg repository User
 
-# 5. Generates an entire full-stack CRUD Resource (Controller, Entity, Repos, DI, etc.)
-nmg resource order
+# Add a DTO validation schema
+nmg dto userRegistration --module=Auth
 ```
 
-_(Note: If you haven't installed the package globally, you can run it via `npx @saulpaulus17/node-module-generator <command> <name>`)_
+---
 
-## 📂 Full Resource Structure
+## 📂 Project Blueprint
 
-Running the powerhouse command `nmg resource user` instantly generates the following decoupled blueprint within your project's `src/modules` directory:
+Scaffolding a module (e.g., `nmg module Product`) produces the following industry-standard structure:
 
 ```text
-src/modules/user/
-├── application/                 # Orchestration & Use Cases
-│   ├── dtos/                    # (Generated schema references)
-│   └── usecases/
-│       ├── create-user.usecase.js      # Business logically perfectly isolated
-│       └── create-user.usecase.test.js # Scaffolded test harness
-├── domain/                      # Blueprints & Business Rules (Pure Logic)
-│   ├── entities/
-│   │   └── user.entity.js
-│   └── repositories/            # Repository Interfaces (Contracts)
-│       └── user.repository.interface.js
-├── infrastructure/              # Technical Details & Implementation
-│   ├── repositories/            # Implementations (mocked to replace with Prisma/TypeORM)
-│   │   └── user.repository.impl.js
-│   └── validation/              # Input validation schemas
-│       └── create-user.schema.js       # Auto-stubbed validation schema
-├── interfaces/                  # Entry Points (Web/API)
-│   ├── controllers/
-│   │   ├── user.controller.js          # Express.js class handlers
-│   │   └── user.controller.test.js
-│   └── routes/
-│       └── user.routes.js              # Express routers integrating the controller
-└── user.module.js               # Centralised Awilix Dependency Injection bindings
+src/modules/Product/
+├── application/                 
+│   ├── dtos/                    # DTO schemas (e.g., product.dto.js)
+│   └── usecases/                # Business orchestration
+│       ├── ProductUseCase.js    # Logic implementation
+│       └── ProductUseCase.test.js # Unit tests
+├── domain/                      
+│   ├── entities/                # Business entity definitions
+│   │   └── Product.js
+│   └── repositories/            # Repository Interface (Contracts)
+│       └── ProductRepository.js
+├── infrastructure/              
+│   ├── repositories/            # Implementation (default: Prisma)
+│   │   └── PrismaProductRepository.js
+├── interfaces/                  
+│   ├── controllers/             # Express handlers
+│   │   ├── ProductController.js
+│   │   └── ProductController.test.js
+│   └── routes/                  # Express routes & method binding
+│       └── product.routes.js
+└── Product.module.js            # Central Awilix Module Registration
 ```
 
-## 🛠️ Technological Footprint
+---
+
+## 🛠️ Post-Scaffolding Integration
+
+To finalize your new module integration, follow these standard steps:
+
+1.  **DI Registration**: Open `src/container.js` and register any specific repository aliases or scoped usecases.
+2.  **Route Mounting**: Mount the generated router in `src/app.js`:
+    ```javascript
+    app.use('/api/v1/product', container.resolve('productRoutes'));
+    ```
+3.  **Detailed Implementation**: Build out the specific logic in the generated templates (which are already integrated via Awilix).
+
+---
 
-The scaffolded code integrates perfectly if you are using the following libraries in your Express application:
+## 🤝 Contributing & Support
 
-- **[Express.js](https://expressjs.com/)** - Web Framework
-- **[Awilix](https://github.com/jeffijoe/awilix)** - Powerful Dependency Injection container
-- **[Jest](https://jestjs.io/)** - For the colocated testing environments
-- **[Joi](https://joi.dev/)** - For infrastructure schema validations
+We welcome contributions from the community!
+1. Fork the project.
+2. Create your Feature Branch (`git checkout -b feat/NewFeature`).
+3. Commit your changes (`git commit -m 'feat: Add some NewFeature'`).
+4. Push to the Branch (`git push origin feat/NewFeature`).
+5. Open a Pull Request.
+
+---
 
 ## 📝 License
 
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+Distributed under the **MIT License**. See `LICENSE` for more information.
+
+---
+<div align="center">
+  <p>Built with ❤️ for modern Node.js developers</p>
+  <sub>Copyright © 2024 saul-paulus</sub>
+</div>

package/generator/dto.generator.js

@@ -5,8 +5,8 @@ const { pascalCase, camelCase } = require("../utils/case.util");
 
 module.exports = async function (schemaName, moduleName) {
   const basePath = path.join(process.cwd(), "src/modules", moduleName);
-  const validationDir = path.join(basePath, "infrastructure/validation");
-  fs.ensureDirSync(validationDir);
+  const dtoDir = path.join(basePath, "application/dtos");
+  fs.ensureDirSync(dtoDir);
 
   const templateData = {
     name: moduleName, 
@@ -15,7 +15,7 @@ module.exports = async function (schemaName, moduleName) {
   };
 
   const templateContent = await ejs.renderFile(path.join(__dirname, "../templates/module/dto.ejs"), templateData);
-  fs.writeFileSync(path.join(validationDir, `${schemaName}.schema.js`), templateContent);
+  fs.writeFileSync(path.join(dtoDir, `${schemaName.toLowerCase()}.dto.js`), templateContent);
 
-  console.log(`✔ DTO Schema ${schemaName} generated inside module ${moduleName}.`);
+  console.log(`✔ DTO ${schemaName} generated inside module ${moduleName} at application/dtos.`);
 };

package/generator/module.generator.js

@@ -9,13 +9,9 @@ module.exports = async function (name) {
   const dirs = [
     "domain/entities",
     "domain/repositories",
-    "domain/services",
     "application/usecases",
     "application/dtos",
     "infrastructure/repositories",
-    "infrastructure/validation",
-    "infrastructure/security",
-    "infrastructure/services",
     "interfaces/controllers",
     "interfaces/routes",
   ];
@@ -23,12 +19,39 @@ module.exports = async function (name) {
   // Create directories
   dirs.forEach((dir) => fs.ensureDirSync(path.join(basePath, dir)));
 
-  console.log(`✔ Module ${name} directory structure created.`);
+  // Generate scoped package.json for ESM support
+  fs.writeJsonSync(path.join(basePath, "package.json"), { type: "module" }, { spaces: 2 });
+
+  const templateData = {
+    name,
+    className: pascalCase(name),
+    camelName: camelCase(name),
+    useCaseClassName: `${pascalCase(name)}UseCase`,
+    useCaseFileName: `${name.toLowerCase()}.usecase`,
+  };
+
+  const renderAndWrite = async (templateName, outputPath) => {
+    const templateContent = await ejs.renderFile(
+      path.join(__dirname, "../templates/module", templateName),
+      templateData
+    );
+    fs.writeFileSync(path.join(basePath, outputPath), templateContent);
+  };
+
+  await renderAndWrite("controller.ejs", `interfaces/controllers/${pascalCase(name)}Controller.js`);
+  await renderAndWrite("controller.test.ejs", `interfaces/controllers/${pascalCase(name)}Controller.test.js`);
+  await renderAndWrite("route.ejs", `interfaces/routes/${name.toLowerCase()}.routes.js`);
+  
+  await renderAndWrite("usecase.ejs", `application/usecases/${pascalCase(name)}UseCase.js`);
+  await renderAndWrite("usecase.test.ejs", `application/usecases/${pascalCase(name)}UseCase.test.js`);
   
-  // Optionally create an empty module DI file
-  const diFile = path.join(basePath, `${name}.module.js`);
-  if (!fs.existsSync(diFile)) {
-    fs.writeFileSync(diFile, `module.exports = function register${pascalCase(name)}Module(container) {\n  container.register({\n    // Inject dependencies here\n  });\n};\n`);
-    console.log(`✔ Module DI registry ${name}.module.js created.`);
-  }
+  await renderAndWrite("entity.ejs", `domain/entities/${pascalCase(name)}.js`);
+  await renderAndWrite("repository.interface.ejs", `domain/repositories/${pascalCase(name)}Repository.js`);
+  
+  await renderAndWrite("repository.impl.ejs", `infrastructure/repositories/Prisma${pascalCase(name)}Repository.js`);
+  await renderAndWrite("dto.ejs", `application/dtos/${name.toLowerCase()}.dto.js`);
+  
+  await renderAndWrite("di.ejs", `${name}.module.js`);
+
+  console.log(`✔ Module ${name} directory structure, standard files, and tests created.`);
 };

package/generator/repository.generator.js

@@ -28,9 +28,9 @@ module.exports = async function (moduleName) {
     fs.writeFileSync(path.join(basePath, outputPath), templateContent);
   };
 
-  await renderAndWrite("entity.ejs", `domain/entities/${moduleName}.entity.js`);
-  await renderAndWrite("repository.interface.ejs", `domain/repositories/${moduleName}.repository.interface.js`);
-  await renderAndWrite("repository.impl.ejs", `infrastructure/repositories/${moduleName}.repository.impl.js`);
+  await renderAndWrite("entity.ejs", `domain/entities/${pascalCase(moduleName)}.js`);
+  await renderAndWrite("repository.interface.ejs", `domain/repositories/${pascalCase(moduleName)}Repository.js`);
+  await renderAndWrite("repository.impl.ejs", `infrastructure/repositories/Prisma${pascalCase(moduleName)}Repository.js`);
 
   console.log(`✔ Repository patterns for ${moduleName} generated successfully.`);
 };

package/generator/resource.generator.js

@@ -9,25 +9,24 @@ module.exports = async function (name) {
   const dirs = [
     "domain/entities",
     "domain/repositories",
-    "domain/services",
     "application/usecases",
     "application/dtos",
     "infrastructure/repositories",
-    "infrastructure/validation",
-    "infrastructure/security",
-    "infrastructure/services",
     "interfaces/controllers",
     "interfaces/routes",
   ];
 
   dirs.forEach((dir) => fs.ensureDirSync(path.join(basePath, dir)));
 
+  // Generate scoped package.json for ESM support
+  fs.writeJsonSync(path.join(basePath, "package.json"), { type: "module" }, { spaces: 2 });
+
   const templateData = {
     name,
     className: pascalCase(name),
     camelName: camelCase(name),
-    useCaseClassName: `Create${pascalCase(name)}UseCase`,
-    useCaseFileName: `create-${name}`,
+    useCaseClassName: `${pascalCase(name)}UseCase`,
+    useCaseFileName: `${name.toLowerCase()}.usecase`,
   };
 
   const renderAndWrite = async (templateName, outputPath) => {
@@ -38,18 +37,18 @@ module.exports = async function (name) {
     fs.writeFileSync(path.join(basePath, outputPath), templateContent);
   };
 
-  await renderAndWrite("controller.ejs", `interfaces/controllers/${name}.controller.js`);
-  await renderAndWrite("controller.test.ejs", `interfaces/controllers/${name}.controller.test.js`);
-  await renderAndWrite("route.ejs", `interfaces/routes/${name}.routes.js`);
+  await renderAndWrite("controller.ejs", `interfaces/controllers/${pascalCase(name)}Controller.js`);
+  await renderAndWrite("controller.test.ejs", `interfaces/controllers/${pascalCase(name)}Controller.test.js`);
+  await renderAndWrite("route.ejs", `interfaces/routes/${name.toLowerCase()}.routes.js`);
   
-  await renderAndWrite("usecase.ejs", `application/usecases/create-${name}.usecase.js`);
-  await renderAndWrite("usecase.test.ejs", `application/usecases/create-${name}.usecase.test.js`);
+  await renderAndWrite("usecase.ejs", `application/usecases/${pascalCase(name)}UseCase.js`);
+  await renderAndWrite("usecase.test.ejs", `application/usecases/${pascalCase(name)}UseCase.test.js`);
   
-  await renderAndWrite("entity.ejs", `domain/entities/${name}.entity.js`);
-  await renderAndWrite("repository.interface.ejs", `domain/repositories/${name}.repository.interface.js`);
+  await renderAndWrite("entity.ejs", `domain/entities/${pascalCase(name)}.js`);
+  await renderAndWrite("repository.interface.ejs", `domain/repositories/${pascalCase(name)}Repository.js`);
   
-  await renderAndWrite("repository.impl.ejs", `infrastructure/repositories/${name}.repository.impl.js`);
-  await renderAndWrite("dto.ejs", `infrastructure/validation/create-${name}.schema.js`);
+  await renderAndWrite("repository.impl.ejs", `infrastructure/repositories/Prisma${pascalCase(name)}Repository.js`);
+  await renderAndWrite("dto.ejs", `application/dtos/${name.toLowerCase()}.dto.js`);
   
   await renderAndWrite("di.ejs", `${name}.module.js`);
 

package/generator/usecase.generator.js

@@ -17,10 +17,10 @@ module.exports = async function (useCaseName, moduleName) {
   };
 
   const templateContent = await ejs.renderFile(path.join(__dirname, "../templates/module/usecase.ejs"), templateData);
-  fs.writeFileSync(path.join(ucDir, `${useCaseName}.usecase.js`), templateContent);
+  fs.writeFileSync(path.join(ucDir, `${pascalCase(useCaseName)}UseCase.js`), templateContent);
 
   const testContent = await ejs.renderFile(path.join(__dirname, "../templates/module/usecase.test.ejs"), templateData);
-  fs.writeFileSync(path.join(ucDir, `${useCaseName}.usecase.test.js`), testContent);
+  fs.writeFileSync(path.join(ucDir, `${pascalCase(useCaseName)}UseCase.test.js`), testContent);
 
   console.log(`✔ Usecase ${useCaseName} generated inside module ${moduleName}.`);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saulpaulus17/node-module-generator",
-  "version": "2.0.2",
+  "version": "2.0.5",
   "description": "CLI tool to grenerate modular scaffolding for nodejs projects following clean arsitecture principles. ",
   "keywords": [
     "nodejs",
@@ -16,7 +16,7 @@
     "nmg": "./bin/cli.js"
   },
   "scripts": {
-    "test": "jest"
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
   },
   "dependencies": {
     "chalk": "^5.6.2",

package/src/modules/Auth/Auth.module.js

@@ -0,0 +1,15 @@
+import { asClass, asFunction } from 'awilix';
+
+import AuthController from './interfaces/controllers/AuthController';
+import createAuthRoutes from './interfaces/routes/auth.routes';
+import CreateAuthUseCase from './application/usecases/CreateAuthUseCase';
+import PrismaAuthRepository from './infrastructure/repositories/PrismaAuthRepository';
+
+export default function registerAuthModule(container) {
+  container.register({
+    authController: asClass(AuthController).singleton(),
+    authRoutes: asFunction(createAuthRoutes).singleton(),
+    CreateAuthUseCase: asClass(CreateAuthUseCase).singleton(),
+    authRepository: asFunction(({ prismaAuthRepository }) => prismaAuthRepository).scoped(),
+  });
+}

package/src/modules/Auth/application/dtos/auth.dto.js

@@ -0,0 +1,10 @@
+// DTO Template
+export default {
+  // Define DTO validation schemas here (e.g. Joi, Zod)
+  createSchema: {
+    // rules
+  },
+  updateSchema: {
+    // rules
+  }
+};

package/src/modules/Auth/application/usecases/AuthUseCase.js

@@ -0,0 +1,12 @@
+export default class AuthUseCase {
+  constructor({ authRepository, jwtService }) {
+    this.authRepository = authRepository;
+    this.jwtService = jwtService;
+  }
+
+  async execute(inputData) {
+    // Logic for AuthUseCase
+    const result = await this.authRepository.create(inputData);
+    return { success: true, data: result };
+  }
+}

package/src/modules/Auth/application/usecases/AuthUseCase.test.js

@@ -0,0 +1,30 @@
+import { jest, describe, it, expect, beforeEach } from '@jest/globals';
+import AuthUseCase from './AuthUseCase.js';
+
+describe('AuthUseCase', () => {
+  let useCase;
+  let mockRepository;
+
+  beforeEach(() => {
+    mockRepository = {
+      create: jest.fn()
+    };
+    useCase = new AuthUseCase({ 
+      authRepository: mockRepository,
+      jwtService: {} 
+    });
+  });
+
+  describe('execute', () => {
+    it('should call repository create and return success', async () => {
+      const mockDto = { name: 'Test' };
+      const mockResult = { id: 1, ...mockDto };
+      mockRepository.create.mockResolvedValue(mockResult);
+
+      const result = await useCase.execute(mockDto);
+
+      expect(mockRepository.create).toHaveBeenCalledWith(mockDto);
+      expect(result).toEqual({ success: true, data: mockResult });
+    });
+  });
+});

package/src/modules/Auth/domain/entities/Auth.js

@@ -0,0 +1,5 @@
+export default class Auth {
+  constructor(props) {
+    Object.assign(this, props);
+  }
+}

package/src/modules/Auth/domain/repositories/AuthRepository.js

@@ -0,0 +1,9 @@
+export default class AuthRepository {
+  async findById(id) {
+    throw new Error('Method not implemented.');
+  }
+
+  async create(data) {
+    throw new Error('Method not implemented.');
+  }
+}

package/src/modules/Auth/infrastructure/repositories/PrismaAuthRepository.js

@@ -0,0 +1,15 @@
+export default class PrismaAuthRepository {
+  constructor({ prisma }) {
+    this.prisma = prisma;
+  }
+
+  async findById(id) {
+    return this.prisma.auths.findUnique({
+      where: { id },
+    });
+  }
+
+  async create(data) {
+    return this.prisma.auths.create({ data });
+  }
+}

package/src/modules/Auth/interfaces/controllers/AuthController.js

@@ -0,0 +1,15 @@
+export default class AuthController {
+  constructor({ authRepository, authUseCase }) {
+    this.authRepository = authRepository;
+    this.authUseCase = authUseCase;
+  }
+
+  async index(req, res, next) {
+    try {
+      const result = await this.authUseCase.execute(req.body);
+      res.json(result);
+    } catch (error) {
+      next(error);
+    }
+  }
+}

package/src/modules/Auth/interfaces/controllers/AuthController.test.js

@@ -0,0 +1,49 @@
+import { jest, describe, it, expect, beforeEach } from '@jest/globals';
+import AuthController from './AuthController.js';
+
+describe('AuthController', () => {
+  let controller;
+  let mockUseCase;
+  let mockReq;
+  let mockRes;
+  let mockNext;
+
+  beforeEach(() => {
+    mockUseCase = {
+      execute: jest.fn()
+    };
+    controller = new AuthController({ 
+      authRepository: {}, 
+      authUseCase: mockUseCase 
+    });
+    mockReq = {
+      body: { test: 'data' }
+    };
+    mockRes = {
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn()
+    };
+    mockNext = jest.fn();
+  });
+
+  describe('index', () => {
+    it('should return result if use case succeeds', async () => {
+      const mockResult = { success: true, data: mockReq.body };
+      mockUseCase.execute.mockResolvedValue(mockResult);
+
+      await controller.index(mockReq, mockRes, mockNext);
+
+      expect(mockUseCase.execute).toHaveBeenCalledWith(mockReq.body);
+      expect(mockRes.json).toHaveBeenCalledWith(mockResult);
+    });
+
+    it('should call next with error if use case fails', async () => {
+      const error = new Error('Test error');
+      mockUseCase.execute.mockRejectedValue(error);
+
+      await controller.index(mockReq, mockRes, mockNext);
+
+      expect(mockNext).toHaveBeenCalledWith(error);
+    });
+  });
+});

package/src/modules/Auth/interfaces/routes/auth.routes.js

@@ -0,0 +1,9 @@
+// routes
+export default ({ authController }) => {
+  const express = require('express');
+  const router = express.Router();
+  
+  router.get('/', authController.index.bind(authController));
+  
+  return router;
+};

package/src/modules/Auth/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/templates/module/controller.ejs

@@ -1,16 +1,15 @@
-class <%= className %>Controller {
-  constructor({ <%= camelName %>UseCase }) {
+export default class <%= className %>Controller {
+  constructor({ <%= camelName %>Repository, <%= camelName %>UseCase }) {
+    this.<%= camelName %>Repository = <%= camelName %>Repository;
     this.<%= camelName %>UseCase = <%= camelName %>UseCase;
   }
 
-  create = async (req, res, next) => {
+  async index(req, res, next) {
     try {
       const result = await this.<%= camelName %>UseCase.execute(req.body);
-      res.status(201).json({ success: true, data: result });
+      res.json(result);
     } catch (error) {
       next(error);
     }
-  };
+  }
 }
-
-module.exports = <%= className %>Controller;

package/templates/module/controller.test.ejs

@@ -1,4 +1,5 @@
-const <%= className %>Controller = require('./<%= name %>.controller');
+import { jest, describe, it, expect, beforeEach } from '@jest/globals';
+import <%= className %>Controller from './<%= className %>Controller.js';
 
 describe('<%= className %>Controller', () => {
   let controller;
@@ -11,7 +12,10 @@ describe('<%= className %>Controller', () => {
     mockUseCase = {
       execute: jest.fn()
     };
-    controller = new <%= className %>Controller({ <%= camelName %>UseCase: mockUseCase });
+    controller = new <%= className %>Controller({ 
+      <%= camelName %>Repository: {}, 
+      <%= camelName %>UseCase: mockUseCase 
+    });
     mockReq = {
       body: { test: 'data' }
     };
@@ -22,23 +26,22 @@ describe('<%= className %>Controller', () => {
     mockNext = jest.fn();
   });
 
-  describe('create', () => {
-    it('should return 201 and result if use case succeeds', async () => {
-      const mockResult = { id: 1, ...mockReq.body };
+  describe('index', () => {
+    it('should return result if use case succeeds', async () => {
+      const mockResult = { success: true, data: mockReq.body };
       mockUseCase.execute.mockResolvedValue(mockResult);
 
-      await controller.create(mockReq, mockRes, mockNext);
+      await controller.index(mockReq, mockRes, mockNext);
 
       expect(mockUseCase.execute).toHaveBeenCalledWith(mockReq.body);
-      expect(mockRes.status).toHaveBeenCalledWith(201);
-      expect(mockRes.json).toHaveBeenCalledWith({ success: true, data: mockResult });
+      expect(mockRes.json).toHaveBeenCalledWith(mockResult);
     });
 
     it('should call next with error if use case fails', async () => {
       const error = new Error('Test error');
       mockUseCase.execute.mockRejectedValue(error);
 
-      await controller.create(mockReq, mockRes, mockNext);
+      await controller.index(mockReq, mockRes, mockNext);
 
       expect(mockNext).toHaveBeenCalledWith(error);
     });

package/templates/module/di.ejs

@@ -1,16 +1,15 @@
-const { asClass, asFunction } = require('awilix');
+import { asClass, asFunction } from 'awilix';
 
-const <%= className %>Controller = require('./interfaces/controllers/<%= name %>.controller');
-const create<%= className %>Routes = require('./interfaces/routes/<%= name %>.routes');
-const Create<%= className %>UseCase = require('./application/usecases/create-<%= name %>.usecase');
-const <%= className %>Repository = require('./infrastructure/repositories/<%= name %>.repository.impl');
+import <%= className %>Controller from './interfaces/controllers/<%= className %>Controller';
+import create<%= className %>Routes from './interfaces/routes/<%= name.toLowerCase() %>.routes';
+import Create<%= className %>UseCase from './application/usecases/Create<%= className %>UseCase';
+import Prisma<%= className %>Repository from './infrastructure/repositories/Prisma<%= className %>Repository';
 
-module.exports = function register<%= className %>Module(container) {
+export default function register<%= className %>Module(container) {
   container.register({
     <%= camelName %>Controller: asClass(<%= className %>Controller).singleton(),
     <%= camelName %>Routes: asFunction(create<%= className %>Routes).singleton(),
-    <%= camelName %>UseCase: asClass(Create<%= className %>UseCase).singleton(),
-    // Providing the interface's name as the injection token for the implementation
-    <%= camelName %>Repository: asClass(<%= className %>Repository).singleton(),
+    Create<%= className %>UseCase: asClass(Create<%= className %>UseCase).singleton(),
+    <%= camelName %>Repository: asFunction(({ prisma<%= className %>Repository }) => prisma<%= className %>Repository).scoped(),
   });
-};
+}

package/templates/module/dto.ejs

@@ -1,7 +1,10 @@
-const Joi = require('joi'); // Usually you'd use joi or another lib
-
-const create<%= className %>Schema = Joi.object({
-  // Define DTO validation rules
-});
-
-module.exports = create<%= className %>Schema;
+// DTO Template
+export default {
+  // Define DTO validation schemas here (e.g. Joi, Zod)
+  createSchema: {
+    // rules
+  },
+  updateSchema: {
+    // rules
+  }
+};

package/templates/module/entity.ejs

@@ -1,8 +1,5 @@
-class <%= className %>Entity {
-  constructor({ id, ...props }) {
-    this.id = id;
+export default class <%= className %> {
+  constructor(props) {
     Object.assign(this, props);
   }
 }
-
-module.exports = <%= className %>Entity;

package/templates/module/repository.impl.ejs

@@ -1,23 +1,15 @@
-const I<%= className %>Repository = require('../../domain/repositories/<%= name %>.repository.interface');
-const <%= className %>Entity = require('../../domain/entities/<%= name %>.entity');
-
-class <%= className %>RepositoryImpl extends I<%= className %>Repository {
-  // If using Prisma, you would do: constructor({ prisma }) { super(); this.prisma = prisma; }
-  constructor() {
-    super();
-    this.db = new Map();
+export default class Prisma<%= className %>Repository {
+  constructor({ prisma }) {
+    this.prisma = prisma;
   }
 
-  async save(dto) {
-    const id = Date.now().toString(); // Mock ID generation
-    const entity = new <%= className %>Entity({ id, ...dto });
-    this.db.set(id, entity);
-    return entity;
+  async findById(id) {
+    return this.prisma.<%= camelName %>s.findUnique({
+      where: { id },
+    });
   }
 
-  async findById(id) {
-    return this.db.get(id) || null;
+  async create(data) {
+    return this.prisma.<%= camelName %>s.create({ data });
   }
 }
-
-module.exports = <%= className %>RepositoryImpl;

package/templates/module/repository.interface.ejs

@@ -1,11 +1,9 @@
-class I<%= className %>Repository {
-  async save(entity) {
+export default class <%= className %>Repository {
+  async findById(id) {
     throw new Error('Method not implemented.');
   }
 
-  async findById(id) {
+  async create(data) {
     throw new Error('Method not implemented.');
   }
 }
-
-module.exports = I<%= className %>Repository;

package/templates/module/route.ejs

@@ -1,9 +1,9 @@
-const { Router } = require('express');
-
-module.exports = function({ <%= camelName %>Controller }) {
-  const router = Router();
-
-  router.post('/', <%= camelName %>Controller.create);
-
+// routes
+export default ({ <%= camelName %>Controller }) => {
+  const express = require('express');
+  const router = express.Router();
+  
+  router.get('/', <%= camelName %>Controller.index.bind(<%= camelName %>Controller));
+  
   return router;
 };

package/templates/module/usecase.ejs

@@ -1,15 +1,12 @@
-class <%= useCaseClassName %> {
-  constructor({ <%= camelName %>Repository }) {
+export default class <%= className %>UseCase {
+  constructor({ <%= camelName %>Repository, jwtService }) {
     this.<%= camelName %>Repository = <%= camelName %>Repository;
+    this.jwtService = jwtService;
   }
 
-  async execute(dto) {
-    // Validate DTO...
-    // Apply business logic...
-    
-    const entity = await this.<%= camelName %>Repository.save(dto);
-    return entity;
+  async execute(inputData) {
+    // Logic for <%= className %>UseCase
+    const result = await this.<%= camelName %>Repository.create(inputData);
+    return { success: true, data: result };
   }
 }
-
-module.exports = <%= useCaseClassName %>;

package/templates/module/usecase.test.ejs

@@ -1,26 +1,30 @@
-const <%= useCaseClassName %> = require('./<%= useCaseFileName %>.usecase');
+import { jest, describe, it, expect, beforeEach } from '@jest/globals';
+import <%= className %>UseCase from './<%= className %>UseCase.js';
 
-describe('<%= useCaseClassName %>', () => {
+describe('<%= className %>UseCase', () => {
   let useCase;
   let mockRepository;
 
   beforeEach(() => {
     mockRepository = {
-      save: jest.fn()
+      create: jest.fn()
     };
-    useCase = new <%= useCaseClassName %>({ <%= camelName %>Repository: mockRepository });
+    useCase = new <%= className %>UseCase({ 
+      <%= camelName %>Repository: mockRepository,
+      jwtService: {} 
+    });
   });
 
   describe('execute', () => {
-    it('should save data using the repository and return the entity', async () => {
+    it('should call repository create and return success', async () => {
       const mockDto = { name: 'Test' };
-      const mockEntity = { id: 1, ...mockDto };
-      mockRepository.save.mockResolvedValue(mockEntity);
+      const mockResult = { id: 1, ...mockDto };
+      mockRepository.create.mockResolvedValue(mockResult);
 
       const result = await useCase.execute(mockDto);
 
-      expect(mockRepository.save).toHaveBeenCalledWith(mockDto);
-      expect(result).toEqual(mockEntity);
+      expect(mockRepository.create).toHaveBeenCalledWith(mockDto);
+      expect(result).toEqual({ success: true, data: mockResult });
     });
   });
 });