@expressots/cli 1.2.1 → 1.3.0-rc-1

package/README.md

@@ -1,17 +1,21 @@
 <p align="center">
-  <a href="https://expresso-ts.com/" target="blank"><img src="https://github.com/expressots/expressots/blob/main/media/alogo.png" width="120" alt="Expresso TS Logo" /></a>
+  <a href="https://expresso-ts.com/" target="blank"><img src="https://github.com/expressots/expressots/blob/main/media/expressots.png" width="120" alt="Expresso TS Logo" /></a>
 </p>
 
+# Expresso TS
+
+A Typescript + [Node.js]("https://nodejs.org/en/") lightweight framework for quick building scalable, easy to read and maintain, server-side applications 🚀
+
 # <h1 align="left">Expresso TS CLI Tool</h1>
 
 ## Description
 
-The Expresso TS CLI is a command-line interface tool that helps you to create `ExpressoTS` projects, develop, and maintain your applications and resources created. It assists in multiple ways, including scaffolding the project as well as the services offered by the application such as use cases, controllers, providers and more.
+The ExpressoTS CLI is a command-line interface tool that helps you to create `ExpressoTS` projects, develop, and maintain your applications and resources created. It assists in multiple ways, including creating the project as well as scaffolding services offered by the application such as use cases, controllers, providers and more.
 
 ## Installation 💻
 
-```
-npm install -g @expressots/cli
+```bash
+npm i -g @expressots/cli
 ```
 
 ## Usage
@@ -20,9 +24,10 @@ Learn more in the [official documentation](https://expresso-ts.com/docs/category
 
 ## Stay in touch
 
+- Author: Daniel Boll | Richard Zampieri
 - Website: [https://expresso-ts.com](https://expresso-ts.com)
 - Twitch:  [@expressots Development](https://www.twitch.tv/richardzampieri)
 
 ## License
 
-Expresso TS is [MIT Licensed](https://github.com/expressots/expressots-cli/blob/main/LICENSE.md)
+ExpressoTS is [MIT Licensed](https://github.com/expressots/expressots-cli/blob/main/LICENSE.md)

package/bin/app.container.d.ts

@@ -0,0 +1 @@
+export {};

package/bin/app.container.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* import { AppContainer } from "@expressots/core";
+import { AppModule } from "./app.module";
+import { UserModule } from "@useCases/user/user.module";
+
+const appContainer = new AppContainer();
+
+const container = appContainer.create([// Add your modules here
+    AppModule, UserModule]);
+
+export { container };
+
+ */ 

package/bin/cli.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export {};
+export declare const CLI_VERSION = "1.2.2";

package/bin/cli.js

@@ -4,15 +4,31 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLI_VERSION = void 0;
 const yargs_1 = __importDefault(require("yargs"));
 const helpers_1 = require("yargs/helpers");
 const generate_1 = require("./generate");
+const info_1 = require("./info");
 const new_1 = require("./new");
+exports.CLI_VERSION = "1.2.2";
+console.log(`\n[🐎 Expressots]\n`);
 (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
-    .example("$0 new <project-name>", "Create a new Expresso TS project")
+    .scriptName("expressots")
     .command((0, new_1.createProject)())
     .command((0, generate_1.generateProject)())
+    .command((0, info_1.infoProject)())
+    .example("$0 new expressots-demo", "Create interactively")
+    .example("$0 new expressots-demo -d ./", "Create interactively with path")
+    .example("$0 new expressots-demo -p yarn -t opinionated", "Create silently")
+    .example("$0 new expressots-demo -p yarn -t opinionated -d ./", "Create silently with path")
+    .example("$0 generate service user-create", "Scaffold a service")
+    .example("$0 info", "Show CLI details")
     .demandCommand(1, "You need at least one command before moving on")
-    .epilog("For more information, visit https://expresso-ts.com")
-    .help()
+    .epilog("For more information: \n" +
+    "🌐 visit:\t https://expresso-ts.com\n" +
+    "💖 Sponsor:\t https://github.com/sponsors/expressots")
+    .help("help", "Show command help")
+    .alias("h", "help")
+    .version(false)
+    .wrap(140)
     .parse();

package/bin/generate/cli.js

@@ -1,15 +1,29 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateProject = void 0;
 const form_1 = require("./form");
-const chalk_1 = __importDefault(require("chalk"));
+const coerceSchematicAliases = (arg) => {
+    switch (arg) {
+        case "u":
+            return "usecase";
+        case "c":
+            return "controller";
+        case "d":
+            return "dto";
+        case "s":
+            return "service";
+        case "p":
+            return "provider";
+        case "e":
+            return "entity";
+        default:
+            return arg;
+    }
+};
 const generateProject = () => {
     return {
         command: "generate [schematic] [path]",
-        describe: "Generate a schematic",
+        describe: "Scaffold a new resource",
         aliases: ["g"],
         builder: (yargs) => {
             yargs.positional("schematic", {
@@ -19,6 +33,7 @@ const generateProject = () => {
                     "dto",
                     "service",
                     "provider",
+                    "entity",
                 ],
                 describe: "The schematic to generate",
                 type: "string",
@@ -27,29 +42,25 @@ const generateProject = () => {
             yargs.positional("path", {
                 describe: "The path to generate the schematic",
                 type: "string",
+                alias: "d",
+            });
+            yargs.positional("method", {
+                choices: [
+                    "get",
+                    "post",
+                    "put",
+                    "patch",
+                    "delete",
+                ],
+                describe: "HTTP method",
+                type: "string",
+                alias: "m",
             });
             return yargs;
         },
-        handler: async ({ schematic, path }) => {
-            const file = await (0, form_1.createTemplate)({ schematic, path });
-            console.log(chalk_1.default.green(`> ${file.split(".")[0]} ${schematic} created! 🚀`));
+        handler: async ({ schematic, path, method }) => {
+            await (0, form_1.createTemplate)({ schematic, path, method });
         },
     };
 };
 exports.generateProject = generateProject;
-const coerceSchematicAliases = (arg) => {
-    switch (arg) {
-        case "u":
-            return "usecase";
-        case "c":
-            return "controller";
-        case "d":
-            return "dto";
-        case "s":
-            return "service";
-        case "p":
-            return "provider";
-        default:
-            return arg;
-    }
-};

package/bin/generate/form.d.ts

@@ -1,6 +1,7 @@
 type CreateTemplateProps = {
     schematic: string;
     path: string;
+    method: string;
 };
-export declare const createTemplate: ({ schematic, path: target, }: CreateTemplateProps) => Promise<string>;
+export declare const createTemplate: ({ schematic, path: target, method, }: CreateTemplateProps) => Promise<string>;
 export {};

package/bin/generate/form.js

@@ -43,37 +43,47 @@ const boost_ts_1 = require("@expressots/boost-ts");
 const compiler_1 = __importDefault(require("../utils/compiler"));
 const add_controller_to_module_1 = require("../utils/add-controller-to-module");
 const verify_file_exists_1 = require("../utils/verify-file-exists");
+const add_module_to_container_1 = require("../utils/add-module-to-container");
+const cli_ui_1 = require("../utils/cli-ui");
 function getFileNameWithoutExtension(filePath) {
     return filePath.split('.')[0];
 }
-const messageColors = {
-    usecase: (text) => chalk_1.default.cyan(text),
-    controller: (text) => chalk_1.default.magenta(text),
-    "controller-service": (text) => chalk_1.default.magenta(text),
-    dto: (text) => chalk_1.default.blue(text),
-    provider: (text) => chalk_1.default.yellow(text),
-    module: (text) => chalk_1.default.red(text),
-};
-const createTemplate = async ({ schematic, path: target, }) => {
+const createTemplate = async ({ schematic, path: target, method, }) => {
     var _a, e_1, _b, _c;
-    const withinSource = schematicFolder(schematic);
-    if (!withinSource)
-        return;
-    const { path, file, className } = await splitTarget({ target, schematic });
-    const { sourceRoot } = await compiler_1.default.loadConfig();
-    const usecaseDir = `${sourceRoot}/${withinSource}`;
-    await (0, verify_file_exists_1.verifyIfFileExists)(`${usecaseDir}/${path}${file}`);
+    const { opinionated, sourceRoot } = await compiler_1.default.loadConfig();
+    if (sourceRoot === "") {
+        (0, cli_ui_1.printError)("You must specify a source root in your expressots.config.ts", "sourceRoot");
+        process.exit(1);
+    }
+    let folderMatch = "";
+    if (opinionated) {
+        folderMatch = schematicFolder(schematic);
+    }
+    else {
+        folderMatch = "";
+    }
+    const { path, file, className, moduleName, modulePath } = await splitTarget({ target, schematic });
+    const usecaseDir = `${sourceRoot}/${folderMatch}`;
+    await (0, verify_file_exists_1.verifyIfFileExists)(`${usecaseDir}/${path}/${file}`);
     (0, node_fs_1.mkdirSync)(`${usecaseDir}/${path}`, { recursive: true });
     if (schematic !== "service") {
-        console.log(messageColors[schematic](`> [${schematic}] Creating ${file}...`));
+        // add to guarantee that the routing will always be the last part of the path
+        let routeSchema = "";
+        if (target.includes("/") || target.includes("\\") || target.includes("//")) {
+            routeSchema = path.split("/").pop();
+        }
+        else {
+            routeSchema = path.replace(/\/$/, '');
+        }
         writeTemplate({
-            outputPath: `${usecaseDir}/${path}${file}`,
+            outputPath: `${usecaseDir}/${path}/${file}`,
             template: {
                 path: `./templates/${schematic}.tpl`,
                 data: {
                     className,
-                    route: path.replace(/\/$/, ''),
+                    route: routeSchema,
                     construct: (0, boost_ts_1.anyCaseToKebabCase)(className),
+                    method: getHttpMethod(method),
                 },
             },
         });
@@ -87,17 +97,50 @@ const createTemplate = async ({ schematic, path: target, }) => {
                     const resource = _c;
                     const currentSchematic = resource.replace("controller-service", "controller");
                     const schematicFile = file.replace(`controller.ts`, `${currentSchematic}.ts`);
-                    console.log(messageColors[currentSchematic](`> [${currentSchematic}] Creating ${schematicFile}...`));
+                    console.log(" ", chalk_1.default.greenBright(`[${currentSchematic}]`.padEnd(14)), chalk_1.default.bold.white(`${schematicFile} created! ✔️`));
+                    let templateBasedMethod = "";
+                    if (method) {
+                        if (resource === "controller-service" || resource === "controller") {
+                            if (method === "get")
+                                templateBasedMethod = `./templates/${resource}.tpl`;
+                            else
+                                templateBasedMethod = `./templates/${resource}-${method}.tpl`;
+                        }
+                        else {
+                            templateBasedMethod = `./templates/${resource}.tpl`;
+                        }
+                        if (resource === "usecase") {
+                            templateBasedMethod = `./templates/${resource}-op.tpl`;
+                        }
+                        if (resource === "usecase") {
+                            if (method === "get")
+                                templateBasedMethod = `./templates/${resource}.tpl`;
+                            if (method === "post")
+                                templateBasedMethod = `./templates/${resource}-${method}.tpl`;
+                        }
+                    }
+                    else {
+                        templateBasedMethod = `./templates/${resource}.tpl`;
+                    }
+                    // add to guarantee that the routing will always be the last part of the path
+                    let routeSchema = "";
+                    if (target.includes("/") || target.includes("\\") || target.includes("//")) {
+                        routeSchema = path.split("/").pop();
+                    }
+                    else {
+                        routeSchema = path.replace(/\/$/, '');
+                    }
                     writeTemplate({
-                        outputPath: `${usecaseDir}/${path}${schematicFile}`,
+                        outputPath: `${usecaseDir}/${path}/${schematicFile}`,
                         template: {
-                            path: `./templates/${currentSchematic}.tpl`,
+                            path: templateBasedMethod,
                             data: {
                                 className,
                                 fileName: getFileNameWithoutExtension(file),
                                 useCase: (0, boost_ts_1.anyCaseToCamelCase)(className),
-                                route: path.replace(/\/$/, ''),
+                                route: routeSchema,
                                 construct: (0, boost_ts_1.anyCaseToKebabCase)(className),
+                                method: getHttpMethod(method),
                             },
                         },
                     });
@@ -115,31 +158,168 @@ const createTemplate = async ({ schematic, path: target, }) => {
             finally { if (e_1) throw e_1.error; }
         }
     }
-    const moduleName = path.split("/")[0];
+    // Module generation
     if (["controller", "service"].includes(schematic)) {
-        if ((0, fs_1.existsSync)(`${usecaseDir}/${moduleName}/${moduleName}.module.ts`)) {
-            console.log(messageColors.module(`> [module] Adding controller to ${moduleName}.module.ts...`));
-            const controllerPath = `./${path.split("/")[1]}/${file.slice(0, file.lastIndexOf('.'))}`;
-            await (0, add_controller_to_module_1.addControllerToModule)(`${usecaseDir}/${moduleName}/${moduleName}.module.ts`, `${className}Controller`, controllerPath);
+        let moduleExist = false;
+        let moduleOutPath = "";
+        if (target.includes("/") || target.includes("\\") || target.includes("//")) {
+            if (modulePath === "") {
+                moduleExist = (0, fs_1.existsSync)(`${usecaseDir}/${moduleName}.module.ts`);
+                moduleOutPath = `${usecaseDir}/${moduleName}.module.ts`;
+            }
+            else {
+                moduleExist = (0, fs_1.existsSync)(`${usecaseDir}/${modulePath}/${moduleName}.module.ts`);
+                moduleOutPath = `${usecaseDir}/${modulePath}/${moduleName}.module.ts`;
+            }
+        }
+        else {
+            moduleExist = (0, fs_1.existsSync)(`${usecaseDir}/${moduleName}/${moduleName}.module.ts`);
+            if (modulePath === "") {
+                moduleExist = (0, fs_1.existsSync)(`${usecaseDir}/${moduleName}.module.ts`);
+                moduleOutPath = `${usecaseDir}/${moduleName}.module.ts`;
+            }
+            else {
+                moduleExist = (0, fs_1.existsSync)(`${usecaseDir}/${moduleName}/${moduleName}.module.ts`);
+                moduleOutPath = `${usecaseDir}/${moduleName}/${moduleName}.module.ts`;
+            }
+        }
+        let controllerPath = "";
+        const pathCount = (path.split("/")).length;
+        if (path === "") {
+            controllerPath = `${file.slice(0, file.lastIndexOf('.'))}`;
+        }
+        else if (pathCount === 1) {
+            controllerPath = `${path}/${file.slice(0, file.lastIndexOf('.'))}`;
+        }
+        else if (pathCount === 2) {
+            controllerPath = `${path.split("/")[1]}/${file.slice(0, file.lastIndexOf('.'))}`;
+        }
+        else {
+            const segments = path.split("/");
+            controllerPath = `${segments[segments.length - 1]}/${file.slice(0, file.lastIndexOf('.'))}`;
+        }
+        if (moduleExist) {
+            if (target.includes("/") || target.includes("\\") || target.includes("//")) {
+                await (0, add_controller_to_module_1.addControllerToModule)(`${usecaseDir}/${modulePath}/${moduleName}.module.ts`, `${className}Controller`, controllerPath);
+            }
+            else {
+                if (modulePath === "") {
+                    await (0, add_controller_to_module_1.addControllerToModule)(`${usecaseDir}/${moduleName}.module.ts`, `${className}Controller`, controllerPath);
+                }
+                else {
+                    await (0, add_controller_to_module_1.addControllerToModule)(`${usecaseDir}/${moduleName}/${moduleName}.module.ts`, `${className}Controller`, controllerPath);
+                }
+            }
         }
         else {
-            console.log(messageColors.module(`> [module] Creating ${moduleName}.module.ts...`));
             writeTemplate({
-                outputPath: `${usecaseDir}/${moduleName}/${moduleName}.module.ts`,
+                outputPath: moduleOutPath,
                 template: {
                     path: `./templates/module.tpl`,
                     data: {
                         moduleName: moduleName[0].toUpperCase() + moduleName.slice(1),
                         className,
-                        path: `${path.split("/")[1]}/${file.slice(0, file.lastIndexOf('.'))}`
+                        path: controllerPath
                     },
                 },
             });
+            console.log(" ", chalk_1.default.greenBright(`[module]`.padEnd(14)), chalk_1.default.bold.white(`${moduleName}.module created! ✔️`));
+            if (target.includes("/") || target.includes("\\") || target.includes("//")) {
+                await (0, add_module_to_container_1.addModuleToContainer)(moduleName, modulePath, path);
+            }
+            else {
+                await (0, add_module_to_container_1.addModuleToContainer)(moduleName, moduleName, path);
+            }
         }
     }
+    if (schematic === "service") {
+        console.log(" ", chalk_1.default.greenBright(`[${schematic}]`.padEnd(14)), chalk_1.default.bold.yellow(`${file.split(".")[0]} created! ✔️`));
+    }
+    else {
+        console.log(" ", chalk_1.default.greenBright(`[${schematic}]`.padEnd(14)), chalk_1.default.bold.white(`${file.split(".")[0]} ${schematic} created! ✔️`));
+    }
     return file;
 };
 exports.createTemplate = createTemplate;
+const splitTarget = async ({ target, schematic, }) => {
+    const pathContent = target.split("/").filter((item) => item !== "");
+    const endsWithSlash = target.endsWith("/");
+    let path = "";
+    let fileName = "";
+    let module = "";
+    let modulePath = "";
+    if (target.includes("/") || target.includes("\\") || target.includes("//")) {
+        //pathContent = target.split("/").filter((item) => item !== "");
+        if (schematic === "service")
+            schematic = "controller";
+        if (schematic === "service" || schematic === "controller" && pathContent.length > 4) {
+            (0, cli_ui_1.printError)("Max path depth is 4.", pathContent.join("/"));
+            process.exit(1);
+        }
+        if (endsWithSlash) {
+            fileName = pathContent[pathContent.length - 1];
+            path = pathContent.join("/");
+            module = (pathContent.length == 1) ? pathContent[pathContent.length - 1] : pathContent[pathContent.length - 2];
+            modulePath = pathContent.slice(0, -1).join("/");
+        }
+        else {
+            fileName = pathContent[pathContent.length - 1];
+            path = pathContent.slice(0, -1).join("/");
+            module = (pathContent.length == 2) ? pathContent[pathContent.length - 2] : pathContent[pathContent.length - 3];
+            modulePath = pathContent.slice(0, -2).join("/");
+        }
+        return {
+            path,
+            file: `${await getNameWithScaffoldPattern(fileName)}.${schematic}.ts`,
+            className: (0, boost_ts_1.anyCaseToPascalCase)(fileName),
+            moduleName: module,
+            modulePath
+        };
+    }
+    else {
+        if (schematic === "service")
+            schematic = "controller";
+        // 1. Extract the name (first part of the target)
+        const [name, ...remainingPath] = target.split("/");
+        // 2. Check if the name is camelCase or kebab-case
+        const camelCaseRegex = /[A-Z]/;
+        const kebabCaseRegex = /[_\-\s]+/;
+        const isCamelCase = camelCaseRegex.test(name);
+        const isKebabCase = kebabCaseRegex.test(name);
+        if (isCamelCase || isKebabCase) {
+            const [wordName, ...path] = name === null || name === void 0 ? void 0 : name.split(isCamelCase ? /(?=[A-Z])/ : kebabCaseRegex).map((word) => word.toLowerCase());
+            return {
+                path: `${wordName}/${pathEdgeCase(path)}${pathEdgeCase(remainingPath)}`,
+                file: `${await getNameWithScaffoldPattern(name)}.${schematic}.ts`,
+                className: (0, boost_ts_1.anyCaseToPascalCase)(name),
+                moduleName: wordName,
+                modulePath: (pathContent[0].split("-")[1])
+            };
+        }
+        // 3. Return the base case
+        return {
+            path: "",
+            file: `${await getNameWithScaffoldPattern(name)}.${schematic}.ts`,
+            className: (0, boost_ts_1.anyCaseToPascalCase)(name),
+            moduleName: name,
+            modulePath: ""
+        };
+    }
+};
+const getHttpMethod = (method) => {
+    switch (method) {
+        case "put":
+            return "httpPut";
+        case "post":
+            return "httpPost";
+        case "patch":
+            return "httpPatch";
+        case "delete":
+            return "httpDelete";
+        default:
+            return "httpGet";
+    }
+};
 const writeTemplate = ({ outputPath, template: { path, data }, }) => {
     (0, fs_1.writeFileSync)(outputPath, (0, mustache_1.render)((0, node_fs_1.readFileSync)(nodePath.join(__dirname, path), "utf8"), data));
 };
@@ -155,50 +335,11 @@ const schematicFolder = (schematic) => {
             return "useCases";
         case "provider":
             return "providers";
+        case "entity":
+            return "entities";
     }
     return undefined;
 };
-const splitTarget = async ({ target, schematic, }) => {
-    if (schematic === "provider")
-        return await splitTargetProviderEdgeCase({ target, schematic });
-    if (schematic === "service")
-        schematic = "controller"; // Anything just to generate
-    // 1. Extract the name (first part of the target)
-    const [name, ...remainingPath] = target.split("/");
-    // 2. Check if the name is camelCase or kebab-case
-    const camelCaseRegex = /[A-Z]/;
-    const kebabCaseRegex = /[_\-\s]+/;
-    const isCamelCase = camelCaseRegex.test(name);
-    const isKebabCase = kebabCaseRegex.test(name);
-    if (isCamelCase || isKebabCase) {
-        const [wordName, ...path] = name === null || name === void 0 ? void 0 : name.split(isCamelCase ? /(?=[A-Z])/ : kebabCaseRegex).map((word) => word.toLowerCase());
-        return {
-            path: `${wordName}/${pathEdgeCase(path)}${pathEdgeCase(remainingPath)}`,
-            file: `${await getNameWithScaffoldPattern(name)}.${schematic}.ts`,
-            className: (0, boost_ts_1.anyCaseToPascalCase)(name),
-        };
-    }
-    // 3. Return the base case
-    return {
-        path: `${name}/${pathEdgeCase(remainingPath)}`,
-        file: `${await getNameWithScaffoldPattern(name)}.${schematic}.ts`,
-        className: (0, boost_ts_1.anyCaseToPascalCase)(name),
-    };
-};
-const splitTargetProviderEdgeCase = async ({ target, schematic, }) => {
-    // Check if the last path ends with a slash, if it does it's supposed to be a folder
-    // and the name of the file will be the same as the folder
-    const isFolder = target.endsWith("/");
-    const path = target.split("/").slice(0, -1);
-    const name = isFolder
-        ? path[path.length - 1]
-        : target.split("/")[target.split("/").length - 1];
-    return {
-        path: pathEdgeCase(path),
-        file: `${await getNameWithScaffoldPattern(name)}.${schematic}.ts`,
-        className: (0, boost_ts_1.anyCaseToPascalCase)(name),
-    };
-};
 const getNameWithScaffoldPattern = async (name) => {
     const configObject = await compiler_1.default.loadConfig();
     switch (configObject.scaffoldPattern) {

package/bin/generate/templates/controller-service-delete.tpl

@@ -0,0 +1,24 @@
+import { BaseController, StatusCode } from "@expressots/core";
+import { controller, {{method}}, requestParam, response } from "inversify-express-utils";
+import { Response } from "express";
+import { {{className}}UseCase } from "./{{fileName}}.usecase";
+import { I{{className}}RequestDTO, I{{className}}ResponseDTO } from "./{{fileName}}.dto";
+
+@controller("/{{{route}}}")
+class {{className}}Controller extends BaseController {
+
+  constructor(private {{useCase}}UseCase: {{className}}UseCase) {
+		super("{{construct}}-controller")
+	}
+
+  @{{method}}("/:id")
+  execute(@requestParam() payload: I{{className}}RequestDTO, @response() res: Response): I{{className}}ResponseDTO {
+    return this.callUseCase(
+            this.{{useCase}}UseCase.execute(payload),
+            res,
+            StatusCode.OK,
+    );
+  }
+}
+
+export { {{className}}Controller };

package/bin/generate/templates/controller-service-patch.tpl

@@ -0,0 +1,28 @@
+import { BaseController, StatusCode } from "@expressots/core";
+import { controller, {{method}}, requestBody, requestParam, response } from "inversify-express-utils";
+import { Response } from "express";
+import { {{className}}UseCase } from "./{{fileName}}.usecase";
+import { I{{className}}RequestDTO, I{{className}}ResponseDTO } from "./{{fileName}}.dto";
+
+@controller("/{{{route}}}")
+class {{className}}Controller extends BaseController {
+
+  constructor(private {{useCase}}UseCase: {{className}}UseCase) {
+		super("{{construct}}-controller")
+	}
+
+  @{{method}}("/:id")
+  execute(
+      @requestParam("id") id: string,
+      @requestBody() payload: I{{className}}RequestDTO,
+      @response() res: Response,
+  ): I{{className}}ResponseDTO {
+      return this.callUseCase(
+            this.{{useCase}}UseCase.execute(id, payload),
+            res,
+            StatusCode.OK,
+      );
+  }
+}
+
+export { {{className}}Controller };

package/bin/generate/templates/controller-service-post.tpl

@@ -0,0 +1,24 @@
+import { BaseController, StatusCode } from "@expressots/core";
+import { controller, {{method}}, requestBody, response } from "inversify-express-utils";
+import { Response } from "express";
+import { {{className}}UseCase } from "./{{fileName}}.usecase";
+import { I{{className}}RequestDTO, I{{className}}ResponseDTO } from "./{{fileName}}.dto";
+
+@controller("/{{{route}}}")
+class {{className}}Controller extends BaseController {
+
+  constructor(private {{useCase}}UseCase: {{className}}UseCase) {
+		super("{{construct}}-controller")
+	}
+
+  @{{method}}("/")
+  execute(@requestBody() payload: I{{className}}RequestDTO, @response() res: Response): I{{className}}ResponseDTO {
+    return this.callUseCase(
+            this.{{useCase}}UseCase.execute(payload),
+            res,
+            StatusCode.Created,
+    );
+  }
+}
+
+export { {{className}}Controller };

package/bin/generate/templates/controller-service-put.tpl

@@ -0,0 +1,28 @@
+import { BaseController, StatusCode } from "@expressots/core";
+import { controller, {{method}}, requestBody, requestParam, response } from "inversify-express-utils";
+import { Response } from "express";
+import { {{className}}UseCase } from "./{{fileName}}.usecase";
+import { I{{className}}RequestDTO, I{{className}}ResponseDTO } from "./{{fileName}}.dto";
+
+@controller("/{{{route}}}")
+class {{className}}Controller extends BaseController {
+
+  constructor(private {{useCase}}UseCase: {{className}}UseCase) {
+		super("{{construct}}-controller")
+	}
+
+  @{{method}}("/:id")
+  execute(
+      @requestParam("id") id: string,
+      @requestBody() payload: I{{className}}RequestDTO,
+      @response() res: Response,
+  ): I{{className}}ResponseDTO {
+      return this.callUseCase(
+            this.{{useCase}}UseCase.execute(id, payload),
+            res,
+            StatusCode.OK,
+      );
+  }
+}
+
+export { {{className}}Controller };