@saulpaulus17/node-module-generator 2.0.8 → 3.1.0

package/README.md

@@ -49,7 +49,7 @@ graph TD
 - 💎 **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.
+- 🚀 **Full ESM Support**: Native support for **ECMAScript Modules (ESM)** with consistent **camelCase** file naming.
 - 🤖 **Granular Control**: Generate full modules or individual components (UseCases, Repos, DTOs) without disrupting existing code.
 
 ---
@@ -127,25 +127,25 @@ Scaffolding a module (e.g., `nmg module Product`) produces the following industr
 ```text
 src/modules/Product/
 ├── application/                 
-│   ├── dtos/                    # DTO schemas (e.g., product.dto.js)
+│   ├── dtos/                    # DTO schemas (e.g., productDto.js)
 │   └── usecases/                # Business orchestration
-│       ├── ProductUseCase.js    # Logic implementation
-│       └── ProductUseCase.test.js # Unit tests
+│       ├── productUseCase.js  # Logic implementation
+│       └── productUseCase.test.js # Unit tests
 ├── domain/                      
 │   ├── entities/                # Business entity definitions
-│   │   └── Product.js
+│   │   └── productEntity.js
 │   └── repositories/            # Repository Interface (Contracts)
-│       └── ProductRepository.js
+│       └── productRepository.js
 ├── infrastructure/              
 │   ├── repositories/            # Implementation (default: Prisma)
-│   │   └── PrismaProductRepository.js
+│   │   └── prismaProductRepository.js
 ├── interfaces/                  
 │   ├── controllers/             # Express handlers
-│   │   ├── ProductController.js
-│   │   └── ProductController.test.js
+│   │   ├── productController.js
+│   │   └── productController.test.js
 │   └── routes/                  # Express routes & method binding
-│       └── product.routes.js
-└── Product.module.js            # Central Awilix Module Registration
+│       └── productRoutes.js
+└── product.module.js            # Central Awilix Module Registration
 ```
 
 ---
@@ -157,7 +157,8 @@ 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'));
+    import productRoutes from './modules/Product/interfaces/routes/productRoutes.js';
+    app.use('/api/v1/product', productRoutes);
     ```
 3.  **Detailed Implementation**: Build out the specific logic in the generated templates (which are already integrated via Awilix).
 

package/bin/cli.js

@@ -1,14 +1,25 @@
 #!/usr/bin/env node
 
-const { Command } = require("commander");
+import { Command } from "commander";
+import moduleCommand from "../commands/module.command.js";
+import usecaseCommand from "../commands/usecase.command.js";
+import resourceCommand from "../commands/resource.command.js";
+import repositoryCommand from "../commands/repository.command.js";
+import dtoCommand from "../commands/dto.command.js";
+
 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);
+process.on("unhandledRejection", (err) => {
+  console.error("✖ FATAL ERROR: ", err.stack || err);
+  process.exit(1);
+});
+
+moduleCommand(program);
+usecaseCommand(program);
+resourceCommand(program);
+repositoryCommand(program);
+dtoCommand(program);
 
 program.parse();

package/commands/dto.command.js

@@ -1,9 +1,9 @@
-const generateDto = require("../generator/dto.generator");
+import generateDto from "../generator/dto.generator.js";
 
-module.exports = (program) => {
+export default (program) => {
   program
     .command("dto <name>")
-    .description("Create a new DTO (validation schema)")
+    .description("Create a new DTO inside an existing module")
     .option("-m, --module <moduleName>", "Specify the target module")
     .action((name, options) => {
       if (!options.module) {

package/commands/module.command.js

@@ -1,6 +1,6 @@
-const generateModule = require("../generator/module.generator");
+import generateModule from "../generator/module.generator.js";
 
-module.exports = (program) => {
+export default (program) => {
   program
     .command("module <name>")
     .description("Create a new module")

package/commands/repository.command.js

@@ -1,10 +1,10 @@
-const generateRepository = require("../generator/repository.generator");
+import generateRepository from "../generator/repository.generator.js";
 
-module.exports = (program) => {
+export default (program) => {
   program
-    .command("repository <moduleName>")
-    .description("Create domain and infrastructure repositories for a module")
-    .action((moduleName) => {
-      generateRepository(moduleName);
+    .command("repository <name>")
+    .description("Create a new repository inside an existing module")
+    .action((name) => {
+      generateRepository(name);
     });
 };

package/commands/resource.command.js

@@ -1,9 +1,9 @@
-const generateResource = require("../generator/resource.generator");
+import generateResource from "../generator/resource.generator.js";
 
-module.exports = (program) => {
+export default (program) => {
   program
     .command("resource <name>")
-    .description("Create a new resource")
+    .description("Create a complete resource (CRUD)")
     .action((name) => {
       generateResource(name);
     });

package/commands/usecase.command.js

@@ -1,6 +1,6 @@
-const generateUsecase = require("../generator/usecase.generator");
+import generateUsecase from "../generator/usecase.generator.js";
 
-module.exports = (program) => {
+export default (program) => {
   program
     .command("usecase <name>")
     .description("Create a new usecase inside an existing module")

package/generator/dto.generator.js

@@ -1,21 +1,32 @@
-const path = require("path");
-const fs = require("fs-extra");
-const ejs = require("ejs");
-const { pascalCase, camelCase } = require("../utils/case.util");
+import path from "path";
+import { pascalCase, camelCase } from "../utils/case.util.js";
+import FileUtil from "../utils/file.util.js";
+import Logger from "../utils/logger.util.js";
 
-module.exports = async function (schemaName, moduleName) {
-  const basePath = path.join(process.cwd(), "src/modules", moduleName);
-  const dtoDir = path.join(basePath, "application/dtos");
-  fs.ensureDirSync(dtoDir);
+export default async function (schemaName, moduleName) {
+  try {
+    Logger.info(`Starting generation for DTO: ${schemaName} in module: ${moduleName}`);
+    const basePath = path.join(process.cwd(), "src/modules", moduleName);
+    const dtoDir = "application/dtos";
+    
+    FileUtil.ensureDirectories(basePath, [dtoDir]);
 
-  const templateData = {
-    name: moduleName, 
-    className: pascalCase(schemaName),
-    camelName: camelCase(moduleName),
-  };
+    const templateData = {
+      name: moduleName, 
+      className: pascalCase(schemaName),
+      camelName: camelCase(schemaName),
+      moduleCamelName: camelCase(moduleName),
+    };
 
-  const templateContent = await ejs.renderFile(path.join(__dirname, "../templates/module/dto.ejs"), templateData);
-  fs.writeFileSync(path.join(dtoDir, `${schemaName.toLowerCase()}.dto.js`), templateContent);
+    await FileUtil.renderAndWrite(
+      "module/dto.ejs",
+      templateData,
+      path.join(basePath, dtoDir, `${camelCase(schemaName)}Dto.js`)
+    );
 
-  console.log(`✔ DTO ${schemaName} generated inside module ${moduleName} at application/dtos.`);
-};
+    Logger.success(`DTO ${schemaName} generated inside module ${moduleName} at application/dtos.`);
+  } catch (error) {
+    Logger.error(`Failed to generate DTO ${schemaName}`, error);
+    process.exit(1);
+  }
+}

package/generator/module.generator.js

@@ -1,55 +1,56 @@
-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",
-    "application/usecases",
-    "application/dtos",
-    "infrastructure/repositories",
-    "interfaces/controllers",
-    "interfaces/routes",
-  ];
-
-  // Create directories
-  dirs.forEach((dir) => fs.ensureDirSync(path.join(basePath, dir)));
-
-
-  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`);
-  
-  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.`);
-};
+import path from "path";
+import { pascalCase, camelCase } from "../utils/case.util.js";
+import FileUtil from "../utils/file.util.js";
+import Logger from "../utils/logger.util.js";
+
+export default async function (name) {
+  try {
+    Logger.info(`Starting generation for module: ${name}`);
+    const basePath = path.join(process.cwd(), "src/modules", name);
+
+    const dirs = [
+      "domain/entities",
+      "domain/repositories",
+      "application/usecases",
+      "application/dtos",
+      "infrastructure/repositories",
+      "interfaces/controllers",
+      "interfaces/routes",
+    ];
+
+    // Create directories
+    FileUtil.ensureDirectories(basePath, dirs);
+
+    const templateData = {
+      name,
+      className: pascalCase(name),
+      camelName: camelCase(name),
+    };
+
+    const filesToGenerate = [
+      { tpl: "module/controller.ejs", out: `interfaces/controllers/${camelCase(name)}Controller.js` },
+      { tpl: "module/controller.test.ejs", out: `interfaces/controllers/${camelCase(name)}Controller.test.js` },
+      { tpl: "module/route.ejs", out: `interfaces/routes/${camelCase(name)}Routes.js` },
+      { tpl: "module/usecase.ejs", out: `application/usecases/${camelCase(name)}UseCase.js` },
+      { tpl: "module/usecase.test.ejs", out: `application/usecases/${camelCase(name)}UseCase.test.js` },
+      { tpl: "module/entity.ejs", out: `domain/entities/${camelCase(name)}Entity.js` },
+      { tpl: "module/repository.interface.ejs", out: `domain/repositories/${camelCase(name)}Repository.js` },
+      { tpl: "module/repository.impl.ejs", out: `infrastructure/repositories/prisma${pascalCase(name)}Repository.js` },
+      { tpl: "module/dto.ejs", out: `application/dtos/${camelCase(name)}Dto.js` },
+      { tpl: "module/di.ejs", out: `${camelCase(name)}.module.js` }
+    ];
+
+    for (const file of filesToGenerate) {
+      await FileUtil.renderAndWrite(
+        file.tpl,
+        templateData,
+        path.join(basePath, file.out)
+      );
+    }
+
+    Logger.success(`Module ${name} generated successfully!`);
+  } catch (error) {
+    Logger.error(`Failed to generate module ${name}`, error);
+    process.exit(1);
+  }
+}

package/generator/repository.generator.js

@@ -1,36 +1,44 @@
-const path = require("path");
-const fs = require("fs-extra");
-const ejs = require("ejs");
-const { pascalCase, camelCase } = require("../utils/case.util");
+import path from "path";
+import { pascalCase, camelCase } from "../utils/case.util.js";
+import FileUtil from "../utils/file.util.js";
+import Logger from "../utils/logger.util.js";
 
-module.exports = async function (moduleName) {
-  const basePath = path.join(process.cwd(), "src/modules", moduleName);
+export default async function (moduleName) {
+  try {
+    Logger.info(`Starting repository pattern generation for module: ${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");
+    const dirs = [
+      "domain/entities",
+      "domain/repositories",
+      "infrastructure/repositories",
+    ];
 
-  fs.ensureDirSync(entityDir);
-  fs.ensureDirSync(repoInterfaceDir);
-  fs.ensureDirSync(repoImplDir);
+    FileUtil.ensureDirectories(basePath, dirs);
 
-  const templateData = {
-    name: moduleName,
-    className: pascalCase(moduleName),
-    camelName: camelCase(moduleName),
-  };
+    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);
-  };
+    const filesToGenerate = [
+      { tpl: "module/entity.ejs", out: `domain/entities/${camelCase(moduleName)}Entity.js` },
+      { tpl: "module/repository.interface.ejs", out: `domain/repositories/${camelCase(moduleName)}Repository.js` },
+      { tpl: "module/repository.impl.ejs", out: `infrastructure/repositories/prisma${pascalCase(moduleName)}Repository.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`);
+    for (const file of filesToGenerate) {
+      await FileUtil.renderAndWrite(
+        file.tpl,
+        templateData,
+        path.join(basePath, file.out)
+      );
+    }
 
-  console.log(`✔ Repository patterns for ${moduleName} generated successfully.`);
-};
+    Logger.success(`Repository patterns for ${moduleName} generated successfully.`);
+  } catch (error) {
+    Logger.error(`Failed to generate repository patterns for ${moduleName}`, error);
+    process.exit(1);
+  }
+}

package/generator/resource.generator.js

@@ -1,54 +1,55 @@
-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",
-    "application/usecases",
-    "application/dtos",
-    "infrastructure/repositories",
-    "interfaces/controllers",
-    "interfaces/routes",
-  ];
-
-  dirs.forEach((dir) => fs.ensureDirSync(path.join(basePath, dir)));
-
-
-  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`);
-  
-  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(`✔ Resource ${name} generated successfully with Clean Architecture and Awilix DI!`);
-};
+import path from "path";
+import { pascalCase, camelCase } from "../utils/case.util.js";
+import FileUtil from "../utils/file.util.js";
+import Logger from "../utils/logger.util.js";
+
+export default async function (name) {
+  try {
+    Logger.info(`Starting generation for resource: ${name}`);
+    const basePath = path.join(process.cwd(), "src/modules", name);
+
+    const dirs = [
+      "domain/entities",
+      "domain/repositories",
+      "application/usecases",
+      "application/dtos",
+      "infrastructure/repositories",
+      "interfaces/controllers",
+      "interfaces/routes",
+    ];
+
+    FileUtil.ensureDirectories(basePath, dirs);
+
+    const templateData = {
+      name,
+      className: pascalCase(name),
+      camelName: camelCase(name),
+    };
+
+    const filesToGenerate = [
+      { tpl: "module/controller.ejs", out: `interfaces/controllers/${camelCase(name)}Controller.js` },
+      { tpl: "module/controller.test.ejs", out: `interfaces/controllers/${camelCase(name)}Controller.test.js` },
+      { tpl: "module/route.ejs", out: `interfaces/routes/${camelCase(name)}Routes.js` },
+      { tpl: "module/usecase.ejs", out: `application/usecases/${camelCase(name)}UseCase.js` },
+      { tpl: "module/usecase.test.ejs", out: `application/usecases/${camelCase(name)}UseCase.test.js` },
+      { tpl: "module/entity.ejs", out: `domain/entities/${camelCase(name)}Entity.js` },
+      { tpl: "module/repository.interface.ejs", out: `domain/repositories/${camelCase(name)}Repository.js` },
+      { tpl: "module/repository.impl.ejs", out: `infrastructure/repositories/prisma${pascalCase(name)}Repository.js` },
+      { tpl: "module/dto.ejs", out: `application/dtos/${camelCase(name)}Dto.js` },
+      { tpl: "module/di.ejs", out: `${camelCase(name)}.module.js` }
+    ];
+
+    for (const file of filesToGenerate) {
+      await FileUtil.renderAndWrite(
+        file.tpl,
+        templateData,
+        path.join(basePath, file.out)
+      );
+    }
+
+    Logger.success(`Resource ${name} generated successfully with Clean Architecture and Awilix DI!`);
+  } catch (error) {
+    Logger.error(`Failed to generate resource ${name}`, error);
+    process.exit(1);
+  }
+}

package/generator/usecase.generator.js

@@ -1,26 +1,38 @@
-const path = require("path");
-const fs = require("fs-extra");
-const ejs = require("ejs");
-const { pascalCase, camelCase } = require("../utils/case.util");
+import path from "path";
+import { pascalCase, camelCase } from "../utils/case.util.js";
+import FileUtil from "../utils/file.util.js";
+import Logger from "../utils/logger.util.js";
 
-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);
+export default async function (useCaseName, moduleName) {
+  try {
+    Logger.info(`Starting usecase generation: ${useCaseName} in module: ${moduleName}`);
+    const basePath = path.join(process.cwd(), "src/modules", moduleName);
+    const ucDir = "application/usecases";
+    
+    FileUtil.ensureDirectories(basePath, [ucDir]);
 
-  const templateData = {
-    name: moduleName, 
-    className: pascalCase(moduleName),
-    camelName: camelCase(moduleName),
-    useCaseClassName: `${pascalCase(useCaseName)}UseCase`,
-    useCaseFileName: useCaseName, 
-  };
+    const templateData = {
+      name: moduleName, 
+      className: pascalCase(useCaseName),
+      camelName: camelCase(moduleName), // This is used for the repository name
+      useCaseCamelName: camelCase(useCaseName),
+    };
 
-  const templateContent = await ejs.renderFile(path.join(__dirname, "../templates/module/usecase.ejs"), templateData);
-  fs.writeFileSync(path.join(ucDir, `${pascalCase(useCaseName)}UseCase.js`), templateContent);
+    await FileUtil.renderAndWrite(
+      "module/usecase.ejs",
+      templateData,
+      path.join(basePath, ucDir, `${camelCase(useCaseName)}UseCase.js`)
+    );
 
-  const testContent = await ejs.renderFile(path.join(__dirname, "../templates/module/usecase.test.ejs"), templateData);
-  fs.writeFileSync(path.join(ucDir, `${pascalCase(useCaseName)}UseCase.test.js`), testContent);
+    await FileUtil.renderAndWrite(
+      "module/usecase.test.ejs",
+      templateData,
+      path.join(basePath, ucDir, `${camelCase(useCaseName)}UseCase.test.js`)
+    );
 
-  console.log(`✔ Usecase ${useCaseName} generated inside module ${moduleName}.`);
-};
+    Logger.success(`Usecase ${useCaseName} generated inside module ${moduleName}.`);
+  } catch (error) {
+    Logger.error(`Failed to generate usecase ${useCaseName}`, error);
+    process.exit(1);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saulpaulus17/node-module-generator",
-  "version": "2.0.8",
+  "version": "3.1.0",
   "description": "CLI tool to grenerate modular scaffolding for nodejs projects following clean arsitecture principles. ",
   "keywords": [
     "nodejs",
@@ -10,7 +10,7 @@
   ],
   "license": "MIT",
   "author": "saul-paulus (ixspx)",
-  "type": "commonjs",
+  "type": "module",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/saul-paulus/node-module-generator.git"
@@ -27,7 +27,7 @@
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
   },
   "dependencies": {
-    "chalk": "^5.6.2",
+    "chalk": "^4.1.2",
     "commander": "^14.0.3",
     "ejs": "^5.0.1",
     "fs-extra": "^11.3.4"

package/templates/module/controller.test.ejs

@@ -1,5 +1,5 @@
 import { jest, describe, it, expect, beforeEach } from '@jest/globals';
-import <%= className %>Controller from './<%= className %>Controller.js';
+import <%= className %>Controller from './<%= camelName %>Controller.js';
 
 describe('<%= className %>Controller', () => {
   let controller;

package/templates/module/di.ejs

@@ -1,15 +1,8 @@
-import { asClass, asFunction } from 'awilix';
-
-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';
+import { asFunction } from 'awilix';
 
 export default function register<%= className %>Module(container) {
   container.register({
-    <%= camelName %>Controller: asClass(<%= className %>Controller).singleton(),
-    <%= camelName %>Routes: asFunction(create<%= className %>Routes).singleton(),
-    Create<%= className %>UseCase: asClass(Create<%= className %>UseCase).singleton(),
     <%= camelName %>Repository: asFunction(({ prisma<%= className %>Repository }) => prisma<%= className %>Repository).scoped(),
   });
 }
+