@expressots/cli 1.5.0 → 1.7.0

package/bin/@types/config.d.ts

@@ -26,5 +26,14 @@ export interface ExpressoConfig {
     sourceRoot: string;
     opinionated: boolean;
     providers?: IProviders;
+    scaffoldSchematics?: {
+        entity?: string;
+        controller?: string;
+        usecase?: string;
+        dto?: string;
+        module?: string;
+        provider?: string;
+        middleware?: string;
+    };
 }
 export {};

package/bin/app.container.js

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

package/bin/cli.d.ts

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

package/bin/cli.js

@@ -4,21 +4,23 @@ 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 project_commands_1 = require("./commands/project.commands");
 const generate_1 = require("./generate");
+const cli_1 = require("./help/cli");
 const info_1 = require("./info");
 const new_1 = require("./new");
 const providers_1 = require("./providers");
-exports.CLI_VERSION = "1.3.4";
 console.log(`\n[🐎 Expressots]\n`);
 (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
     .scriptName("expressots")
+    .command(project_commands_1.runCommandModule)
     .command((0, new_1.createProject)())
     .command((0, providers_1.generateProviders)())
     .command((0, generate_1.generateProject)())
     .command((0, info_1.infoProject)())
+    .command((0, cli_1.helpCommand)())
     .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")

package/bin/commands/project.commands.d.ts

@@ -0,0 +1,8 @@
+import { CommandModule } from "yargs";
+export declare const runCommandModule: CommandModule<{}, {
+    command: string;
+}>;
+declare const runCommand: ({ command }: {
+    command: string;
+}) => Promise<void>;
+export { runCommand };

package/bin/commands/project.commands.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommand = exports.runCommandModule = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const compiler_1 = __importDefault(require("../utils/compiler"));
+/**
+ * Load the configuration from the compiler
+ * @param compiler The compiler to load the configuration from
+ * @returns The configuration
+ */
+const opinionatedConfig = [
+    "--transpile-only",
+    "-r",
+    "dotenv/config",
+    "-r",
+    "tsconfig-paths/register",
+    "./src/main.ts",
+];
+const nonOpinionatedConfig = [
+    "--transpile-only",
+    "-r",
+    "dotenv/config",
+    "./src/main.ts",
+];
+/**
+ * Helper function to execute a command
+ * @param command The command to execute
+ * @param args The arguments to pass to the command
+ * @param cwd The current working directory to execute the command in
+ * @returns A promise that resolves when the command completes successfully
+ */
+function execCmd(command, args, cwd = process.cwd()) {
+    return new Promise((resolve, reject) => {
+        const proc = (0, child_process_1.spawn)(command, args, {
+            stdio: "inherit",
+            shell: true,
+            cwd,
+        });
+        proc.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`Command failed with code ${code}`));
+            }
+        });
+    });
+}
+// Helper to delete the dist directory
+const cleanDist = async () => {
+    await fs_1.promises.rm("./dist", { recursive: true, force: true });
+};
+// Helper to compile TypeScript
+const compileTypescript = async () => {
+    await execCmd("npx", ["tsc", "-p", "tsconfig.build.json"]);
+};
+// Helper to copy files
+const copyFiles = async () => {
+    const { opinionated } = await compiler_1.default.loadConfig();
+    let filesToCopy = [];
+    if (opinionated) {
+        filesToCopy = [
+            "./register-path.js",
+            "tsconfig.build.json",
+            "package.json",
+        ];
+    }
+    else {
+        filesToCopy = ["tsconfig.json", "package.json"];
+    }
+    filesToCopy.forEach((file) => {
+        fs_1.promises.copyFile(file, path_1.default.join("./dist", path_1.default.basename(file)));
+    });
+};
+// eslint-disable-next-line @typescript-eslint/ban-types
+exports.runCommandModule = {
+    command: "run <command>",
+    describe: "Runs a specified command (dev, build, prod)",
+    builder: (yargs) => {
+        return yargs.positional("command", {
+            describe: "The command to run",
+            type: "string",
+            choices: ["dev", "build", "prod"],
+        });
+    },
+    handler: async (argv) => {
+        const { command } = argv;
+        // Now call your original runCommand function with the command
+        // Ensure runCommand is properly defined to handle these commands
+        await runCommand({ command });
+    },
+};
+const runCommand = async ({ command }) => {
+    const { opinionated } = await compiler_1.default.loadConfig();
+    try {
+        switch (command) {
+            case "dev":
+                // Use execSync or spawn to run ts-node-dev programmatically
+                execCmd("tsnd", opinionated ? opinionatedConfig : nonOpinionatedConfig);
+                break;
+            case "build":
+                await cleanDist();
+                await compileTypescript();
+                await copyFiles();
+                break;
+            case "prod":
+                let config = [];
+                if (opinionated) {
+                    config = [
+                        "-r",
+                        "dotenv/config",
+                        "-r",
+                        "./dist/register-path.js",
+                        "./dist/src/main.js",
+                    ];
+                }
+                else {
+                    config = ["-r", "dotenv/config", "./dist/main.js"];
+                }
+                // Ensure environment variables are set
+                execCmd("node", config);
+                break;
+            default:
+                console.log(`Unknown command: ${command}`);
+        }
+    }
+    catch (error) {
+        console.error("Error executing command:", error);
+    }
+};
+exports.runCommand = runCommand;

package/bin/generate/cli.js

@@ -16,15 +16,17 @@ const coerceSchematicAliases = (arg) => {
             return "provider";
         case "e":
             return "entity";
-        case "m":
+        case "mo":
             return "module";
+        case "mi":
+            return "middleware";
         default:
             return arg;
     }
 };
 const generateProject = () => {
     return {
-        command: "generate [schematic] [path]",
+        command: "generate [schematic] [path] [method]",
         describe: "Scaffold a new resource",
         aliases: ["g"],
         builder: (yargs) => {
@@ -37,6 +39,7 @@ const generateProject = () => {
                     "provider",
                     "entity",
                     "module",
+                    "middleware",
                 ],
                 describe: "The schematic to generate",
                 type: "string",

package/bin/generate/form.d.ts

@@ -1,7 +1,20 @@
+/**
+ * Create a template props
+ * @param schematic
+ * @param path
+ * @param method
+ */
 type CreateTemplateProps = {
     schematic: string;
     path: string;
     method: string;
 };
+/**
+ * Create a template based on the schematic
+ * @param schematic - the schematic to create
+ * @param path - the path to create the schematic
+ * @param method - the http method
+ * @returns the file created
+ */
 export declare const createTemplate: ({ schematic, path: target, method, }: CreateTemplateProps) => Promise<string>;
 export {};

package/bin/generate/form.js

@@ -1,387 +1,30 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTemplate = void 0;
-const nodePath = __importStar(require("path"));
-const node_fs_1 = require("node:fs");
-const mustache_1 = require("mustache");
-const fs_1 = require("fs");
-const chalk_1 = __importDefault(require("chalk"));
-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 command_utils_1 = require("./utils/command-utils");
+const nonopininated_cmd_1 = require("./utils/nonopininated-cmd");
+const opinionated_cmd_1 = require("./utils/opinionated-cmd");
+/**
+ * Create a template based on the schematic
+ * @param schematic - the schematic to create
+ * @param path - the path to create the schematic
+ * @param method - the http method
+ * @returns the file created
+ */
 const createTemplate = async ({ schematic, path: target, method, }) => {
-    var _a, e_1, _b, _c;
-    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") {
-        // 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(/\/$/, "");
-        }
-        let templateBasedSchematic = schematic;
-        if (schematic === "module") {
-            templateBasedSchematic = "module-default";
-        }
-        writeTemplate({
-            outputPath: `${usecaseDir}/${path}/${file}`,
-            template: {
-                path: `./templates/${templateBasedSchematic}.tpl`,
-                data: {
-                    className,
-                    moduleName: className,
-                    route: routeSchema,
-                    construct: (0, boost_ts_1.anyCaseToKebabCase)(className),
-                    method: getHttpMethod(method),
-                },
-            },
-        });
-    }
-    else {
-        try {
-            for (var _d = true, _e = __asyncValues(["controller-service", "usecase", "dto"]), _f; _f = await _e.next(), _a = _f.done, !_a;) {
-                _c = _f.value;
-                _d = false;
-                try {
-                    const resource = _c;
-                    const currentSchematic = resource.replace("controller-service", "controller");
-                    const schematicFile = file.replace(`controller.ts`, `${currentSchematic}.ts`);
-                    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}`,
-                        template: {
-                            path: templateBasedMethod,
-                            data: {
-                                className,
-                                fileName: getFileNameWithoutExtension(file),
-                                useCase: (0, boost_ts_1.anyCaseToCamelCase)(className),
-                                route: routeSchema,
-                                construct: (0, boost_ts_1.anyCaseToKebabCase)(className),
-                                method: getHttpMethod(method),
-                            },
-                        },
-                    });
-                }
-                finally {
-                    _d = true;
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-    }
-    // Module generation
-    if (["controller", "service"].includes(schematic)) {
-        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("/")
-                .filter((segment) => segment !== "");
-            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 {
-            writeTemplate({
-                outputPath: moduleOutPath,
-                template: {
-                    path: `./templates/module.tpl`,
-                    data: {
-                        moduleName: moduleName[0].toUpperCase() + moduleName.slice(1),
-                        className,
-                        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! ✔️`));
+    const config = await compiler_1.default.loadConfig();
+    const pathStyle = (0, command_utils_1.checkPathStyle)(target);
+    let returnFile = "";
+    if (config.opinionated) {
+        returnFile = await (0, opinionated_cmd_1.opinionatedProcess)(schematic, target, method, config, pathStyle);
     }
     else {
-        console.log(" ", chalk_1.default.greenBright(`[${schematic}]`.padEnd(14)), chalk_1.default.bold.white(`${file.split(".")[0]} ${schematic} created! ✔️`));
+        returnFile = await (0, nonopininated_cmd_1.nonOpinionatedProcess)(schematic, target, method, config);
     }
-    return file;
+    return returnFile;
 };
 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 "Put";
-        case "post":
-            return "Post";
-        case "patch":
-            return "Patch";
-        case "delete":
-            return "Delete";
-        default:
-            return "Get";
-    }
-};
-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));
-};
-const schematicFolder = (schematic) => {
-    switch (schematic) {
-        case "usecase":
-            return "useCases";
-        case "controller":
-            return "useCases";
-        case "dto":
-            return "useCases";
-        case "service":
-            return "useCases";
-        case "provider":
-            return "providers";
-        case "entity":
-            return "entities";
-    }
-    return undefined;
-};
-const getNameWithScaffoldPattern = async (name) => {
-    const configObject = await compiler_1.default.loadConfig();
-    switch (configObject.scaffoldPattern) {
-        case "lowercase" /* Pattern.LOWER_CASE */:
-            return (0, boost_ts_1.anyCaseToLowerCase)(name);
-        case "kebab-case" /* Pattern.KEBAB_CASE */:
-            return (0, boost_ts_1.anyCaseToKebabCase)(name);
-        case "PascalCase" /* Pattern.PASCAL_CASE */:
-            return (0, boost_ts_1.anyCaseToPascalCase)(name);
-        case "camelCase" /* Pattern.CAMEL_CASE */:
-            return (0, boost_ts_1.anyCaseToCamelCase)(name);
-    }
-};
-const pathEdgeCase = (path) => {
-    return `${path.join("/")}${path.length > 0 ? "/" : ""}`;
-};

package/bin/generate/templates/nonopinionated/controller.tpl

@@ -0,0 +1,10 @@
+import { BaseController } from "@expressots/core";
+import { controller, {{method}} } from "@expressots/adapter-express";
+
+@controller("/{{{route}}}")
+export class {{className}}{{schematic}} {
+    @{{method}}("/")
+    execute() {
+        return "{{schematic}}";
+    }
+}

package/bin/generate/templates/nonopinionated/dto.tpl

@@ -0,0 +1,3 @@
+export interface I{{className}}Request{{schematic}} {}
+
+export interface I{{className}}Response{{schematic}} {}