@saulpaulus17/node-module-generator 2.0.2

package/.github/workflows/ci.yml

@@ -0,0 +1,28 @@
+name: CI
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [18, 20]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+      - name: Cache node modules
+        uses: actions/cache@v4
+        with:
+          path: ~/.npm
+          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
+      - name: Install dependencies
+        run: npm ci
+      - name: Run tests
+        run: npm test

package/.github/workflows/release.yml

@@ -0,0 +1,31 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*.*.*'
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install deps
+        run: npm install
+
+      - name: Run test
+        run: npm test
+
+      - name: Publish to npm
+        run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ixspx-dev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,103 @@
+<div align="center">
+  <h1>🚀 Node Module Generator</h1>
+  <p>A robust CLI tool for scaffolding Express.js projects using Clean Architecture & Dependency Injection.</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>
+  </p>
+</div>
+
+---
+
+## 📖 Overview
+
+**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**.
+
+## ✨ Features
+
+- 🏗️ **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.
+
+```bash
+# Install globally via NPM
+npm install -g @saulpaulus17/node-module-generator
+```
+
+## 🚀 Usage
+
+Once installed globally, you can execute the CLI commands from any of your Node.js project directories using the `nmg` command keyword.
+
+### Granular CLI Commands
+Scaffold specifically what you need, exactly how you do it in NestJS:
+
+```bash
+# 1. Scaffolds a new module architecture and empty DI registry
+nmg module product
+
+# 2. Creates a specific Use Case and its Test inside an existing module
+nmg usecase updateProduct --module=product
+
+# 3. Creates Domain Entity and Repository Interfaces/Implementations
+nmg repository product
+
+# 4. Scaffolds a DTO validation schema
+nmg dto getProduct --module=product
+
+# 5. Generates an entire full-stack CRUD Resource (Controller, Entity, Repos, DI, etc.)
+nmg resource order
+```
+
+_(Note: If you haven't installed the package globally, you can run it via `npx @saulpaulus17/node-module-generator <command> <name>`)_
+
+## 📂 Full Resource Structure
+
+Running the powerhouse command `nmg resource user` instantly generates the following decoupled blueprint within your project's `src/modules` directory:
+
+```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
+```
+
+## 🛠️ Technological Footprint
+
+The scaffolded code integrates perfectly if you are using the following libraries in your Express application:
+
+- **[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
+
+## 📝 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/SECURITY.md

@@ -0,0 +1,21 @@
+# Security Policy
+
+## Supported Versions
+
+Use this section to tell people about which versions of your project are
+currently being supported with security updates.
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 5.1.x   | :white_check_mark: |
+| 5.0.x   | :x:                |
+| 4.0.x   | :white_check_mark: |
+| < 4.0   | :x:                |
+
+## Reporting a Vulnerability
+
+Use this section to tell people how to report a vulnerability.
+
+Tell them where to go, how often they can expect to get an update on a
+reported vulnerability, what to expect if the vulnerability is accepted or
+declined, etc.

package/bin/cli.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+
+const { Command } = require("commander");
+const program = new Command();
+
+program.name("nmg").version("1.0.0").description("Clean nodejs CLI");
+
+require("../commands/module.command")(program);
+require("../commands/usecase.command")(program);
+require("../commands/resource.command")(program);
+require("../commands/repository.command")(program);
+require("../commands/dto.command")(program);
+
+program.parse();

package/commands/dto.command.js

@@ -0,0 +1,15 @@
+const generateDto = require("../generator/dto.generator");
+
+module.exports = (program) => {
+  program
+    .command("dto <name>")
+    .description("Create a new DTO (validation schema)")
+    .option("-m, --module <moduleName>", "Specify the target module")
+    .action((name, options) => {
+      if (!options.module) {
+        console.error("error: required option '-m, --module <moduleName>' not specified");
+        process.exit(1);
+      }
+      generateDto(name, options.module);
+    });
+};

package/commands/module.command.js

@@ -0,0 +1,10 @@
+const generateModule = require("../generator/module.generator");
+
+module.exports = (program) => {
+  program
+    .command("module <name>")
+    .description("Create a new module")
+    .action((name) => {
+      generateModule(name);
+    });
+};

package/commands/repository.command.js

@@ -0,0 +1,10 @@
+const generateRepository = require("../generator/repository.generator");
+
+module.exports = (program) => {
+  program
+    .command("repository <moduleName>")
+    .description("Create domain and infrastructure repositories for a module")
+    .action((moduleName) => {
+      generateRepository(moduleName);
+    });
+};

package/commands/resource.command.js

@@ -0,0 +1,10 @@
+const generateResource = require("../generator/resource.generator");
+
+module.exports = (program) => {
+  program
+    .command("resource <name>")
+    .description("Create a new resource")
+    .action((name) => {
+      generateResource(name);
+    });
+};

package/commands/usecase.command.js

@@ -0,0 +1,15 @@
+const generateUsecase = require("../generator/usecase.generator");
+
+module.exports = (program) => {
+  program
+    .command("usecase <name>")
+    .description("Create a new usecase inside an existing module")
+    .option("-m, --module <moduleName>", "Specify the target module")
+    .action((name, options) => {
+      if (!options.module) {
+        console.error("error: required option '-m, --module <moduleName>' not specified");
+        process.exit(1);
+      }
+      generateUsecase(name, options.module);
+    });
+};

package/generator/dto.generator.js

@@ -0,0 +1,21 @@
+const path = require("path");
+const fs = require("fs-extra");
+const ejs = require("ejs");
+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 templateData = {
+    name: moduleName, 
+    className: pascalCase(schemaName),
+    camelName: camelCase(moduleName),
+  };
+
+  const templateContent = await ejs.renderFile(path.join(__dirname, "../templates/module/dto.ejs"), templateData);
+  fs.writeFileSync(path.join(validationDir, `${schemaName}.schema.js`), templateContent);
+
+  console.log(`✔ DTO Schema ${schemaName} generated inside module ${moduleName}.`);
+};

package/generator/module.generator.js

@@ -0,0 +1,34 @@
+const path = require("path");
+const fs = require("fs-extra");
+const ejs = require("ejs");
+const { pascalCase, camelCase } = require("../utils/case.util");
+
+module.exports = async function (name) {
+  const basePath = path.join(process.cwd(), "src/modules", 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",
+  ];
+
+  // Create directories
+  dirs.forEach((dir) => fs.ensureDirSync(path.join(basePath, dir)));
+
+  console.log(`✔ Module ${name} directory structure created.`);
+  
+  // 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.`);
+  }
+};

package/generator/repository.generator.js

@@ -0,0 +1,36 @@
+const path = require("path");
+const fs = require("fs-extra");
+const ejs = require("ejs");
+const { pascalCase, camelCase } = require("../utils/case.util");
+
+module.exports = async function (moduleName) {
+  const basePath = path.join(process.cwd(), "src/modules", moduleName);
+
+  const entityDir = path.join(basePath, "domain/entities");
+  const repoInterfaceDir = path.join(basePath, "domain/repositories");
+  const repoImplDir = path.join(basePath, "infrastructure/repositories");
+
+  fs.ensureDirSync(entityDir);
+  fs.ensureDirSync(repoInterfaceDir);
+  fs.ensureDirSync(repoImplDir);
+
+  const templateData = {
+    name: moduleName,
+    className: pascalCase(moduleName),
+    camelName: camelCase(moduleName),
+  };
+
+  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("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`);
+
+  console.log(`✔ Repository patterns for ${moduleName} generated successfully.`);
+};

package/generator/resource.generator.js

@@ -0,0 +1,57 @@
+const path = require("path");
+const fs = require("fs-extra");
+const ejs = require("ejs");
+const { pascalCase, camelCase } = require("../utils/case.util");
+
+module.exports = async function (name) {
+  const basePath = path.join(process.cwd(), "src/modules", 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)));
+
+  const templateData = {
+    name,
+    className: pascalCase(name),
+    camelName: camelCase(name),
+    useCaseClassName: `Create${pascalCase(name)}UseCase`,
+    useCaseFileName: `create-${name}`,
+  };
+
+  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/${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("usecase.ejs", `application/usecases/create-${name}.usecase.js`);
+  await renderAndWrite("usecase.test.ejs", `application/usecases/create-${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("repository.impl.ejs", `infrastructure/repositories/${name}.repository.impl.js`);
+  await renderAndWrite("dto.ejs", `infrastructure/validation/create-${name}.schema.js`);
+  
+  await renderAndWrite("di.ejs", `${name}.module.js`);
+
+  console.log(`✔ Resource ${name} generated successfully with Clean Architecture and Awilix DI!`);
+};

package/generator/usecase.generator.js

@@ -0,0 +1,26 @@
+const path = require("path");
+const fs = require("fs-extra");
+const ejs = require("ejs");
+const { pascalCase, camelCase } = require("../utils/case.util");
+
+module.exports = async function (useCaseName, moduleName) {
+  const basePath = path.join(process.cwd(), "src/modules", moduleName);
+  const ucDir = path.join(basePath, "application/usecases");
+  fs.ensureDirSync(ucDir);
+
+  const templateData = {
+    name: moduleName, 
+    className: pascalCase(moduleName),
+    camelName: camelCase(moduleName),
+    useCaseClassName: `${pascalCase(useCaseName)}UseCase`,
+    useCaseFileName: useCaseName, 
+  };
+
+  const templateContent = await ejs.renderFile(path.join(__dirname, "../templates/module/usecase.ejs"), templateData);
+  fs.writeFileSync(path.join(ucDir, `${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);
+
+  console.log(`✔ Usecase ${useCaseName} generated inside module ${moduleName}.`);
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@saulpaulus17/node-module-generator",
+  "version": "2.0.2",
+  "description": "CLI tool to grenerate modular scaffolding for nodejs projects following clean arsitecture principles. ",
+  "keywords": [
+    "nodejs",
+    "module-generator",
+    "module",
+    "clean-architecture"
+  ],
+  "license": "MIT",
+  "author": "saul-paulus (ixspx)",
+  "type": "commonjs",
+  "main": "index.js",
+  "bin": {
+    "nmg": "./bin/cli.js"
+  },
+  "scripts": {
+    "test": "jest"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "ejs": "^5.0.1",
+    "fs-extra": "^11.3.4"
+  },
+  "devDependencies": {
+    "jest": "^30.3.0"
+  }
+}

package/src/modules/order/application/usecases/create-order.usecase.js

@@ -0,0 +1,15 @@
+class CreateOrderUseCase {
+  constructor({ orderRepository }) {
+    this.orderRepository = orderRepository;
+  }
+
+  async execute(dto) {
+    // Validate DTO...
+    // Apply business logic...
+    
+    const entity = await this.orderRepository.save(dto);
+    return entity;
+  }
+}
+
+module.exports = CreateOrderUseCase;

package/src/modules/order/application/usecases/create-order.usecase.test.js

@@ -0,0 +1,26 @@
+const CreateOrderUseCase = require('./create-order.usecase');
+
+describe('CreateOrderUseCase', () => {
+  let useCase;
+  let mockRepository;
+
+  beforeEach(() => {
+    mockRepository = {
+      save: jest.fn()
+    };
+    useCase = new CreateOrderUseCase({ orderRepository: mockRepository });
+  });
+
+  describe('execute', () => {
+    it('should save data using the repository and return the entity', async () => {
+      const mockDto = { name: 'Test' };
+      const mockEntity = { id: 1, ...mockDto };
+      mockRepository.save.mockResolvedValue(mockEntity);
+
+      const result = await useCase.execute(mockDto);
+
+      expect(mockRepository.save).toHaveBeenCalledWith(mockDto);
+      expect(result).toEqual(mockEntity);
+    });
+  });
+});

package/src/modules/order/domain/entities/order.entity.js

@@ -0,0 +1,8 @@
+class OrderEntity {
+  constructor({ id, ...props }) {
+    this.id = id;
+    Object.assign(this, props);
+  }
+}
+
+module.exports = OrderEntity;

package/src/modules/order/domain/repositories/order.repository.interface.js

@@ -0,0 +1,11 @@
+class IOrderRepository {
+  async save(entity) {
+    throw new Error('Method not implemented.');
+  }
+
+  async findById(id) {
+    throw new Error('Method not implemented.');
+  }
+}
+
+module.exports = IOrderRepository;

package/src/modules/order/infrastructure/repositories/order.repository.impl.js

@@ -0,0 +1,23 @@
+const IOrderRepository = require('../../domain/repositories/order.repository.interface');
+const OrderEntity = require('../../domain/entities/order.entity');
+
+class OrderRepositoryImpl extends IOrderRepository {
+  // If using Prisma, you would do: constructor({ prisma }) { super(); this.prisma = prisma; }
+  constructor() {
+    super();
+    this.db = new Map();
+  }
+
+  async save(dto) {
+    const id = Date.now().toString(); // Mock ID generation
+    const entity = new OrderEntity({ id, ...dto });
+    this.db.set(id, entity);
+    return entity;
+  }
+
+  async findById(id) {
+    return this.db.get(id) || null;
+  }
+}
+
+module.exports = OrderRepositoryImpl;

package/src/modules/order/infrastructure/validation/create-order.schema.js

@@ -0,0 +1,7 @@
+const Joi = require('joi'); // Usually you'd use joi or another lib
+
+const createOrderSchema = Joi.object({
+  // Define DTO validation rules
+});
+
+module.exports = createOrderSchema;

package/src/modules/order/interfaces/controllers/order.controller.js

@@ -0,0 +1,16 @@
+class OrderController {
+  constructor({ orderUseCase }) {
+    this.orderUseCase = orderUseCase;
+  }
+
+  create = async (req, res, next) => {
+    try {
+      const result = await this.orderUseCase.execute(req.body);
+      res.status(201).json({ success: true, data: result });
+    } catch (error) {
+      next(error);
+    }
+  };
+}
+
+module.exports = OrderController;

package/src/modules/order/interfaces/controllers/order.controller.test.js

@@ -0,0 +1,46 @@
+const OrderController = require('./order.controller');
+
+describe('OrderController', () => {
+  let controller;
+  let mockUseCase;
+  let mockReq;
+  let mockRes;
+  let mockNext;
+
+  beforeEach(() => {
+    mockUseCase = {
+      execute: jest.fn()
+    };
+    controller = new OrderController({ orderUseCase: mockUseCase });
+    mockReq = {
+      body: { test: 'data' }
+    };
+    mockRes = {
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn()
+    };
+    mockNext = jest.fn();
+  });
+
+  describe('create', () => {
+    it('should return 201 and result if use case succeeds', async () => {
+      const mockResult = { id: 1, ...mockReq.body };
+      mockUseCase.execute.mockResolvedValue(mockResult);
+
+      await controller.create(mockReq, mockRes, mockNext);
+
+      expect(mockUseCase.execute).toHaveBeenCalledWith(mockReq.body);
+      expect(mockRes.status).toHaveBeenCalledWith(201);
+      expect(mockRes.json).toHaveBeenCalledWith({ success: true, data: 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);
+
+      expect(mockNext).toHaveBeenCalledWith(error);
+    });
+  });
+});

package/src/modules/order/interfaces/routes/order.routes.js

@@ -0,0 +1,9 @@
+const { Router } = require('express');
+
+module.exports = function({ orderController }) {
+  const router = Router();
+
+  router.post('/', orderController.create);
+
+  return router;
+};

package/src/modules/order/order.module.js

@@ -0,0 +1,16 @@
+const { asClass, asFunction } = require('awilix');
+
+const OrderController = require('./interfaces/controllers/order.controller');
+const createOrderRoutes = require('./interfaces/routes/order.routes');
+const CreateOrderUseCase = require('./application/usecases/create-order.usecase');
+const OrderRepository = require('./infrastructure/repositories/order.repository.impl');
+
+module.exports = function registerOrderModule(container) {
+  container.register({
+    orderController: asClass(OrderController).singleton(),
+    orderRoutes: asFunction(createOrderRoutes).singleton(),
+    orderUseCase: asClass(CreateOrderUseCase).singleton(),
+    // Providing the interface's name as the injection token for the implementation
+    orderRepository: asClass(OrderRepository).singleton(),
+  });
+};

package/src/modules/product/application/usecases/getProduct.usecase.js

@@ -0,0 +1,15 @@
+class GetproductUseCase {
+  constructor({ productRepository }) {
+    this.productRepository = productRepository;
+  }
+
+  async execute(dto) {
+    // Validate DTO...
+    // Apply business logic...
+    
+    const entity = await this.productRepository.save(dto);
+    return entity;
+  }
+}
+
+module.exports = GetproductUseCase;

package/src/modules/product/application/usecases/getProduct.usecase.test.js

@@ -0,0 +1,26 @@
+const GetproductUseCase = require('./getProduct.usecase');
+
+describe('GetproductUseCase', () => {
+  let useCase;
+  let mockRepository;
+
+  beforeEach(() => {
+    mockRepository = {
+      save: jest.fn()
+    };
+    useCase = new GetproductUseCase({ productRepository: mockRepository });
+  });
+
+  describe('execute', () => {
+    it('should save data using the repository and return the entity', async () => {
+      const mockDto = { name: 'Test' };
+      const mockEntity = { id: 1, ...mockDto };
+      mockRepository.save.mockResolvedValue(mockEntity);
+
+      const result = await useCase.execute(mockDto);
+
+      expect(mockRepository.save).toHaveBeenCalledWith(mockDto);
+      expect(result).toEqual(mockEntity);
+    });
+  });
+});

package/src/modules/product/domain/entities/product.entity.js

@@ -0,0 +1,8 @@
+class ProductEntity {
+  constructor({ id, ...props }) {
+    this.id = id;
+    Object.assign(this, props);
+  }
+}
+
+module.exports = ProductEntity;

package/src/modules/product/domain/repositories/product.repository.interface.js

@@ -0,0 +1,11 @@
+class IProductRepository {
+  async save(entity) {
+    throw new Error('Method not implemented.');
+  }
+
+  async findById(id) {
+    throw new Error('Method not implemented.');
+  }
+}
+
+module.exports = IProductRepository;

package/src/modules/product/infrastructure/repositories/product.repository.impl.js

@@ -0,0 +1,23 @@
+const IProductRepository = require('../../domain/repositories/product.repository.interface');
+const ProductEntity = require('../../domain/entities/product.entity');
+
+class ProductRepositoryImpl extends IProductRepository {
+  // If using Prisma, you would do: constructor({ prisma }) { super(); this.prisma = prisma; }
+  constructor() {
+    super();
+    this.db = new Map();
+  }
+
+  async save(dto) {
+    const id = Date.now().toString(); // Mock ID generation
+    const entity = new ProductEntity({ id, ...dto });
+    this.db.set(id, entity);
+    return entity;
+  }
+
+  async findById(id) {
+    return this.db.get(id) || null;
+  }
+}
+
+module.exports = ProductRepositoryImpl;

package/src/modules/product/infrastructure/validation/getProduct.schema.js

@@ -0,0 +1,7 @@
+const Joi = require('joi'); // Usually you'd use joi or another lib
+
+const createGetproductSchema = Joi.object({
+  // Define DTO validation rules
+});
+
+module.exports = createGetproductSchema;

package/src/modules/product/product.module.js

@@ -0,0 +1,5 @@
+module.exports = function registerProductModule(container) {
+  container.register({
+    // Inject dependencies here
+  });
+};

package/src/modules/user/application/usecases/create-user.usecase.js

@@ -0,0 +1,15 @@
+class CreateUserUseCase {
+  constructor({ userRepository }) {
+    this.userRepository = userRepository;
+  }
+
+  async execute(dto) {
+    // Validate DTO...
+    // Apply business logic...
+    
+    const entity = await this.userRepository.save(dto);
+    return entity;
+  }
+}
+
+module.exports = CreateUserUseCase;

package/src/modules/user/application/usecases/create-user.usecase.test.js

@@ -0,0 +1,26 @@
+const CreateUserUseCase = require('./create-user.usecase');
+
+describe('CreateUserUseCase', () => {
+  let useCase;
+  let mockRepository;
+
+  beforeEach(() => {
+    mockRepository = {
+      save: jest.fn()
+    };
+    useCase = new CreateUserUseCase({ userRepository: mockRepository });
+  });
+
+  describe('execute', () => {
+    it('should save data using the repository and return the entity', async () => {
+      const mockDto = { name: 'Test' };
+      const mockEntity = { id: 1, ...mockDto };
+      mockRepository.save.mockResolvedValue(mockEntity);
+
+      const result = await useCase.execute(mockDto);
+
+      expect(mockRepository.save).toHaveBeenCalledWith(mockDto);
+      expect(result).toEqual(mockEntity);
+    });
+  });
+});

package/src/modules/user/domain/entities/user.entity.js

@@ -0,0 +1,8 @@
+class UserEntity {
+  constructor({ id, ...props }) {
+    this.id = id;
+    Object.assign(this, props);
+  }
+}
+
+module.exports = UserEntity;

package/src/modules/user/domain/repositories/user.repository.interface.js

@@ -0,0 +1,11 @@
+class IUserRepository {
+  async save(entity) {
+    throw new Error('Method not implemented.');
+  }
+
+  async findById(id) {
+    throw new Error('Method not implemented.');
+  }
+}
+
+module.exports = IUserRepository;

package/src/modules/user/infrastructure/repositories/user.repository.impl.js

@@ -0,0 +1,23 @@
+const IUserRepository = require('../../domain/repositories/user.repository.interface');
+const UserEntity = require('../../domain/entities/user.entity');
+
+class UserRepositoryImpl extends IUserRepository {
+  // If using Prisma, you would do: constructor({ prisma }) { super(); this.prisma = prisma; }
+  constructor() {
+    super();
+    this.db = new Map();
+  }
+
+  async save(dto) {
+    const id = Date.now().toString(); // Mock ID generation
+    const entity = new UserEntity({ id, ...dto });
+    this.db.set(id, entity);
+    return entity;
+  }
+
+  async findById(id) {
+    return this.db.get(id) || null;
+  }
+}
+
+module.exports = UserRepositoryImpl;

package/src/modules/user/infrastructure/validation/create-user.schema.js

@@ -0,0 +1,7 @@
+const Joi = require('joi'); // Usually you'd use joi or another lib
+
+const createUserSchema = Joi.object({
+  // Define DTO validation rules
+});
+
+module.exports = createUserSchema;

package/src/modules/user/interfaces/controllers/user.controller.js

@@ -0,0 +1,16 @@
+class UserController {
+  constructor({ userUseCase }) {
+    this.userUseCase = userUseCase;
+  }
+
+  create = async (req, res, next) => {
+    try {
+      const result = await this.userUseCase.execute(req.body);
+      res.status(201).json({ success: true, data: result });
+    } catch (error) {
+      next(error);
+    }
+  };
+}
+
+module.exports = UserController;

package/src/modules/user/interfaces/controllers/user.controller.test.js

@@ -0,0 +1,46 @@
+const UserController = require('./user.controller');
+
+describe('UserController', () => {
+  let controller;
+  let mockUseCase;
+  let mockReq;
+  let mockRes;
+  let mockNext;
+
+  beforeEach(() => {
+    mockUseCase = {
+      execute: jest.fn()
+    };
+    controller = new UserController({ userUseCase: mockUseCase });
+    mockReq = {
+      body: { test: 'data' }
+    };
+    mockRes = {
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn()
+    };
+    mockNext = jest.fn();
+  });
+
+  describe('create', () => {
+    it('should return 201 and result if use case succeeds', async () => {
+      const mockResult = { id: 1, ...mockReq.body };
+      mockUseCase.execute.mockResolvedValue(mockResult);
+
+      await controller.create(mockReq, mockRes, mockNext);
+
+      expect(mockUseCase.execute).toHaveBeenCalledWith(mockReq.body);
+      expect(mockRes.status).toHaveBeenCalledWith(201);
+      expect(mockRes.json).toHaveBeenCalledWith({ success: true, data: 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);
+
+      expect(mockNext).toHaveBeenCalledWith(error);
+    });
+  });
+});

package/src/modules/user/interfaces/routes/user.routes.js

@@ -0,0 +1,9 @@
+const { Router } = require('express');
+
+module.exports = function({ userController }) {
+  const router = Router();
+
+  router.post('/', userController.create);
+
+  return router;
+};

package/src/modules/user/user.module.js

@@ -0,0 +1,16 @@
+const { asClass, asFunction } = require('awilix');
+
+const UserController = require('./interfaces/controllers/user.controller');
+const createUserRoutes = require('./interfaces/routes/user.routes');
+const CreateUserUseCase = require('./application/usecases/create-user.usecase');
+const UserRepository = require('./infrastructure/repositories/user.repository.impl');
+
+module.exports = function registerUserModule(container) {
+  container.register({
+    userController: asClass(UserController).singleton(),
+    userRoutes: asFunction(createUserRoutes).singleton(),
+    userUseCase: asClass(CreateUserUseCase).singleton(),
+    // Providing the interface's name as the injection token for the implementation
+    userRepository: asClass(UserRepository).singleton(),
+  });
+};

package/templates/module/controller.ejs

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

package/templates/module/controller.test.ejs

@@ -0,0 +1,46 @@
+const <%= className %>Controller = require('./<%= name %>.controller');
+
+describe('<%= className %>Controller', () => {
+  let controller;
+  let mockUseCase;
+  let mockReq;
+  let mockRes;
+  let mockNext;
+
+  beforeEach(() => {
+    mockUseCase = {
+      execute: jest.fn()
+    };
+    controller = new <%= className %>Controller({ <%= camelName %>UseCase: mockUseCase });
+    mockReq = {
+      body: { test: 'data' }
+    };
+    mockRes = {
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn()
+    };
+    mockNext = jest.fn();
+  });
+
+  describe('create', () => {
+    it('should return 201 and result if use case succeeds', async () => {
+      const mockResult = { id: 1, ...mockReq.body };
+      mockUseCase.execute.mockResolvedValue(mockResult);
+
+      await controller.create(mockReq, mockRes, mockNext);
+
+      expect(mockUseCase.execute).toHaveBeenCalledWith(mockReq.body);
+      expect(mockRes.status).toHaveBeenCalledWith(201);
+      expect(mockRes.json).toHaveBeenCalledWith({ success: true, data: 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);
+
+      expect(mockNext).toHaveBeenCalledWith(error);
+    });
+  });
+});

package/templates/module/di.ejs

@@ -0,0 +1,16 @@
+const { asClass, asFunction } = require('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');
+
+module.exports = 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(),
+  });
+};

package/templates/module/dto.ejs

@@ -0,0 +1,7 @@
+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;

package/templates/module/entity.ejs

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

package/templates/module/repository.impl.ejs

@@ -0,0 +1,23 @@
+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();
+  }
+
+  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.db.get(id) || null;
+  }
+}
+
+module.exports = <%= className %>RepositoryImpl;

package/templates/module/repository.interface.ejs

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

package/templates/module/route.ejs

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

package/templates/module/usecase.ejs

@@ -0,0 +1,15 @@
+class <%= useCaseClassName %> {
+  constructor({ <%= camelName %>Repository }) {
+    this.<%= camelName %>Repository = <%= camelName %>Repository;
+  }
+
+  async execute(dto) {
+    // Validate DTO...
+    // Apply business logic...
+    
+    const entity = await this.<%= camelName %>Repository.save(dto);
+    return entity;
+  }
+}
+
+module.exports = <%= useCaseClassName %>;

package/templates/module/usecase.test.ejs

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

package/utils/case.util.js

@@ -0,0 +1,10 @@
+exports.pascalCase = (str) => {
+  const words = str.match(/[a-z0-9]+/gi) || [];
+  return words.map(w => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join('');
+};
+
+exports.camelCase = (str) => {
+  const words = str.match(/[a-z0-9]+/gi) || [];
+  if (!words.length) return '';
+  return words[0].toLowerCase() + words.slice(1).map(w => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join('');
+};