@expressots/cli 1.6.0 → 1.7.1

package/bin/generate/utils/opinionated-cmd.js

@@ -0,0 +1,480 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opinionatedProcess = void 0;
+const boost_ts_1 = require("@expressots/boost-ts");
+const nodePath = __importStar(require("node:path"));
+const fs_1 = __importDefault(require("fs"));
+const cli_ui_1 = require("../../utils/cli-ui");
+const command_utils_1 = require("./command-utils");
+const add_controller_to_module_1 = require("../../utils/add-controller-to-module");
+const add_module_to_container_1 = require("../../utils/add-module-to-container");
+/**
+ * Process commands for opinionated service scaffolding
+ * @param schematic - Resource to scaffold
+ * @param target - Target path
+ * @param method - HTTP method
+ * @param expressoConfig - Expresso configuration [expressots.config.ts]
+ * @param pathStyle - Path command style [sugar, nested, single]
+ * @returns
+ */
+async function opinionatedProcess(schematic, target, method, expressoConfig, pathStyle) {
+    const f = await (0, command_utils_1.validateAndPrepareFile)({
+        schematic,
+        target,
+        method,
+        expressoConfig,
+    });
+    switch (schematic) {
+        case "service":
+            await generateControllerService(f.outputPath, f.className, f.path, method, f.file);
+            const u = await (0, command_utils_1.validateAndPrepareFile)({
+                schematic: "usecase",
+                target,
+                method,
+                expressoConfig,
+            });
+            await generateUseCaseService(u.outputPath, u.className, method, u.moduleName, u.path, u.fileName);
+            const d = await (0, command_utils_1.validateAndPrepareFile)({
+                schematic: "dto",
+                target,
+                method,
+                expressoConfig,
+            });
+            await generateDTO(d.outputPath, d.className, d.moduleName, d.path);
+            const m = await (0, command_utils_1.validateAndPrepareFile)({
+                schematic: "module",
+                target,
+                method,
+                expressoConfig,
+            });
+            if (pathStyle === "sugar" /* PathStyle.Sugar */) {
+                await generateModuleServiceSugarPath(f.outputPath, m.className, m.moduleName, m.path, m.file, m.folderToScaffold);
+            }
+            else if (pathStyle === "nested" /* PathStyle.Nested */) {
+                await generateModuleServiceNestedPath(f.outputPath, m.className, m.path, m.folderToScaffold);
+            }
+            else if (pathStyle === "single" /* PathStyle.Single */) {
+                await generateModuleServiceSinglePath(f.outputPath, m.className, m.moduleName, m.path, m.file, m.folderToScaffold);
+            }
+            await (0, cli_ui_1.printGenerateSuccess)("controller", f.file);
+            await (0, cli_ui_1.printGenerateSuccess)("usecase", f.file);
+            await (0, cli_ui_1.printGenerateSuccess)("dto", f.file);
+            await (0, cli_ui_1.printGenerateSuccess)("module", f.file);
+            break;
+        case "usecase":
+            await generateUseCase(f.outputPath, f.className, f.moduleName, f.path, f.fileName);
+            await (0, cli_ui_1.printGenerateSuccess)(schematic, f.file);
+            break;
+        case "controller":
+            await generateController(f.outputPath, f.className, f.path, method, f.file);
+            await (0, cli_ui_1.printGenerateSuccess)(schematic, f.file);
+            break;
+        case "dto":
+            await generateDTO(f.outputPath, f.className, f.moduleName, f.path);
+            await (0, cli_ui_1.printGenerateSuccess)(schematic, f.file);
+            break;
+        case "provider":
+            await generateProvider(f.outputPath, f.className, f.moduleName, f.path);
+            await (0, cli_ui_1.printGenerateSuccess)(schematic, f.file);
+            break;
+        case "entity":
+            await generateEntity(f.outputPath, f.className, f.moduleName, f.path);
+            await (0, cli_ui_1.printGenerateSuccess)(schematic, f.file);
+            break;
+        case "middleware":
+            await generateMiddleware(f.outputPath, f.className, f.moduleName, f.path);
+            await (0, cli_ui_1.printGenerateSuccess)(schematic, f.file);
+            break;
+        case "module":
+            await generateModule(f.outputPath, f.className, f.moduleName, f.path);
+            await (0, cli_ui_1.printGenerateSuccess)(schematic, f.file);
+            break;
+    }
+    return f.file;
+}
+exports.opinionatedProcess = opinionatedProcess;
+/* Generate Resource */
+/**
+ * Generate a controller service
+ * @param outputPath - The output path
+ * @param className - The class name
+ * @param moduleName - The module name
+ * @param path - The path
+ * @param method - The method
+ * @param file - The file
+ */
+async function generateControllerService(outputPath, className, path, method, file) {
+    let templateBasedMethod = "";
+    switch (method) {
+        case "put":
+            templateBasedMethod =
+                "../templates/opinionated/controller-service-put.tpl";
+            break;
+        case "patch":
+            templateBasedMethod =
+                "../templates/opinionated/controller-service-patch.tpl";
+            break;
+        case "post":
+            templateBasedMethod =
+                "../templates/opinionated/controller-service-post.tpl";
+            break;
+        case "delete":
+            templateBasedMethod =
+                "../templates/opinionated/controller-service-delete.tpl";
+            break;
+        default:
+            templateBasedMethod =
+                "../templates/opinionated/controller-service-get.tpl";
+            break;
+    }
+    (0, command_utils_1.writeTemplate)({
+        outputPath,
+        template: {
+            path: templateBasedMethod,
+            data: {
+                className,
+                fileName: (0, command_utils_1.getFileNameWithoutExtension)(file),
+                useCase: (0, boost_ts_1.anyCaseToCamelCase)(className),
+                route: path.replace(/\/$/, ""),
+                construct: (0, boost_ts_1.anyCaseToKebabCase)(className),
+                method: (0, command_utils_1.getHttpMethod)(method),
+            },
+        },
+    });
+}
+/**
+ * Generate a use case
+ * @param outputPath - The output path
+ * @param className - The class name
+ * @param moduleName - The module name
+ * @param path - The path
+ * @param template - The template
+ */
+async function generateUseCaseService(outputPath, className, method, moduleName, path, fileName) {
+    let templateBasedMethod = "";
+    switch (method) {
+        case "put":
+            templateBasedMethod =
+                "../templates/opinionated/usecase-service.tpl";
+            break;
+        case "patch":
+            templateBasedMethod =
+                "../templates/opinionated/usecase-service.tpl";
+            break;
+        case "post":
+            templateBasedMethod =
+                "../templates/opinionated/usecase-service.tpl";
+            break;
+        case "delete":
+            templateBasedMethod =
+                "../templates/opinionated/usecase-service-delete.tpl";
+            break;
+        default:
+            templateBasedMethod = "../templates/opinionated/usecase.tpl";
+            break;
+    }
+    (0, command_utils_1.writeTemplate)({
+        outputPath,
+        template: {
+            path: templateBasedMethod,
+            data: {
+                className,
+                moduleName,
+                path,
+                fileName,
+            },
+        },
+    });
+}
+/**
+ * Generate a use case
+ * @param outputPath - The output path
+ * @param className - The class name
+ * @param moduleName - The module name
+ * @param path - The path
+ * @param fileName - The file name
+ */
+async function generateUseCase(outputPath, className, moduleName, path, fileName) {
+    (0, command_utils_1.writeTemplate)({
+        outputPath,
+        template: {
+            path: "../templates/opinionated/usecase.tpl",
+            data: {
+                className,
+                moduleName,
+                path,
+                fileName,
+            },
+        },
+    });
+}
+/**
+ * Generate a controller
+ * @param outputPath - The output path
+ * @param className - The class name
+ * @param path - The path
+ * @param method - The method
+ * @param file - The file
+ */
+async function generateController(outputPath, className, path, method, file) {
+    const templateBasedMethod = "../templates/opinionated/controller-service.tpl";
+    (0, command_utils_1.writeTemplate)({
+        outputPath,
+        template: {
+            path: templateBasedMethod,
+            data: {
+                className,
+                fileName: (0, command_utils_1.getFileNameWithoutExtension)(file),
+                useCase: (0, boost_ts_1.anyCaseToCamelCase)(className),
+                route: path.replace(/\/$/, ""),
+                construct: (0, boost_ts_1.anyCaseToKebabCase)(className),
+                method: (0, command_utils_1.getHttpMethod)(method),
+            },
+        },
+    });
+}
+/**
+ * Generate a DTO
+ * @param outputPath - The output path
+ * @param className - The class name
+ * @param moduleName - The module name
+ * @param path - The path
+ */
+async function generateDTO(outputPath, className, moduleName, path) {
+    (0, command_utils_1.writeTemplate)({
+        outputPath,
+        template: {
+            path: "../templates/opinionated/dto.tpl",
+            data: {
+                className,
+                moduleName,
+                path,
+            },
+        },
+    });
+}
+/**
+ * Generate a provider
+ * @param outputPath - The output path
+ * @param className - The class name
+ * @param moduleName - The module name
+ * @param path - The path
+ */
+async function generateProvider(outputPath, className, moduleName, path) {
+    (0, command_utils_1.writeTemplate)({
+        outputPath,
+        template: {
+            path: "../templates/opinionated/provider.tpl",
+            data: {
+                className,
+                moduleName,
+                path,
+            },
+        },
+    });
+}
+/**
+ * Generate an entity
+ * @param outputPath - The output path
+ * @param className - The class name
+ * @param moduleName - The module name
+ * @param path - The path
+ */
+async function generateEntity(outputPath, className, moduleName, path) {
+    (0, command_utils_1.writeTemplate)({
+        outputPath,
+        template: {
+            path: "../templates/opinionated/entity.tpl",
+            data: {
+                className,
+                moduleName,
+                path,
+            },
+        },
+    });
+}
+/**
+ * Generate a middleware
+ * @param outputPath - The output path
+ * @param className - The class name
+ * @param moduleName - The module name
+ * @param path - The path
+ */
+async function generateMiddleware(outputPath, className, moduleName, path) {
+    (0, command_utils_1.writeTemplate)({
+        outputPath,
+        template: {
+            path: "../templates/opinionated/middleware.tpl",
+            data: {
+                className,
+                moduleName,
+                path,
+            },
+        },
+    });
+}
+/**
+ * Generate a module for service scaffolding with sugar path
+ * @param outputPath - The output path
+ * @param className - The class name
+ * @param moduleName - The module name
+ * @param path - The path
+ */
+async function generateModuleServiceSugarPath(outputPathController, className, moduleName, path, file, folderToScaffold) {
+    const newModuleFile = await (0, command_utils_1.extractFirstWord)(file);
+    const newModulePath = nodePath
+        .join(folderToScaffold, path, "..")
+        .normalize();
+    const newModuleName = `${newModuleFile}.module.ts`;
+    const newModuleOutputPath = `${newModulePath}/${newModuleName}`.replace("\\", "/");
+    const controllerToModule = nodePath
+        .relative(newModuleOutputPath, outputPathController)
+        .normalize()
+        .replace(/\.ts$/, "")
+        .replace(/\\/g, "/")
+        .replace(/\.\./g, ".");
+    const controllerFullPath = nodePath
+        .join(folderToScaffold, path, "..", newModuleName)
+        .normalize();
+    if (fs_1.default.existsSync(newModuleOutputPath)) {
+        await (0, add_controller_to_module_1.addControllerToModule)(controllerFullPath, `${className}Controller`, controllerToModule);
+        return;
+    }
+    (0, command_utils_1.writeTemplate)({
+        outputPath: newModuleOutputPath,
+        template: {
+            path: "../templates/opinionated/module-service.tpl",
+            data: {
+                className,
+                moduleName: (0, boost_ts_1.anyCaseToPascalCase)(moduleName),
+                path: controllerToModule,
+            },
+        },
+    });
+    await (0, add_module_to_container_1.addModuleToContainer)((0, boost_ts_1.anyCaseToPascalCase)(moduleName), `${moduleName}/${file.replace(".ts", "")}`, path);
+}
+/**
+ * Generate a module for service scaffolding with single path
+ * @param outputPath - The output path
+ * @param className - The class name
+ * @param moduleName - The module name
+ * @param path - The path
+ */
+async function generateModuleServiceSinglePath(outputPathController, className, moduleName, path, file, folderToScaffold) {
+    const newModuleFile = await (0, command_utils_1.extractFirstWord)(file);
+    const newModulePath = nodePath.join(folderToScaffold, path).normalize();
+    const newModuleName = `${newModuleFile}.module.ts`;
+    const newModuleOutputPath = `${newModulePath}/${newModuleName}`.replace("\\", "/");
+    const controllerToModule = nodePath
+        .relative(newModuleOutputPath, outputPathController)
+        .normalize()
+        .replace(/\.ts$/, "")
+        .replace(/\\/g, "/")
+        .replace(/\.\./g, ".");
+    const controllerFullPath = nodePath
+        .join(folderToScaffold, path, "..", newModuleName)
+        .normalize();
+    if (fs_1.default.existsSync(newModuleOutputPath)) {
+        await (0, add_controller_to_module_1.addControllerToModule)(controllerFullPath, `${className}Controller`, controllerToModule);
+        return;
+    }
+    (0, command_utils_1.writeTemplate)({
+        outputPath: newModuleOutputPath,
+        template: {
+            path: "../templates/opinionated/module-service.tpl",
+            data: {
+                className,
+                moduleName: (0, boost_ts_1.anyCaseToPascalCase)(moduleName),
+                path: controllerToModule,
+            },
+        },
+    });
+    await (0, add_module_to_container_1.addModuleToContainer)((0, boost_ts_1.anyCaseToPascalCase)(moduleName), `${moduleName}/${file.replace(".ts", "")}`, path);
+}
+/**
+ * Generate a module for service scaffolding with nested path
+ * @param outputPathController
+ * @param className
+ * @param path
+ * @param folderToScaffold
+ * @returns
+ */
+async function generateModuleServiceNestedPath(outputPathController, className, path, folderToScaffold) {
+    const moduleFileName = nodePath.basename(path, "/");
+    const newModulePath = nodePath
+        .join(folderToScaffold, path, "..")
+        .normalize();
+    const newModuleName = `${moduleFileName}.module.ts`;
+    const newModuleOutputPath = `${newModulePath}/${newModuleName}`.replace("\\", "/");
+    const controllerToModule = nodePath
+        .relative(newModuleOutputPath, outputPathController)
+        .normalize()
+        .replace(/\.ts$/, "")
+        .replace(/\\/g, "/")
+        .replace(/\.\./g, ".");
+    const controllerFullPath = nodePath
+        .join(folderToScaffold, path, "..", newModuleName)
+        .normalize();
+    if (fs_1.default.existsSync(newModuleOutputPath)) {
+        await (0, add_controller_to_module_1.addControllerToModule)(controllerFullPath, `${className}Controller`, controllerToModule);
+        return;
+    }
+    (0, command_utils_1.writeTemplate)({
+        outputPath: newModuleOutputPath,
+        template: {
+            path: "../templates/opinionated/module-service.tpl",
+            data: {
+                className,
+                moduleName: (0, boost_ts_1.anyCaseToPascalCase)(moduleFileName),
+                path: controllerToModule,
+            },
+        },
+    });
+    await (0, add_module_to_container_1.addModuleToContainerNestedPath)((0, boost_ts_1.anyCaseToPascalCase)(moduleFileName), path);
+}
+/**
+ * Generate a module
+ * @param outputPath - The output path
+ * @param className - The class name
+ * @param moduleName - The module name
+ * @param path - The path
+ */
+async function generateModule(outputPath, className, moduleName, path) {
+    (0, command_utils_1.writeTemplate)({
+        outputPath,
+        template: {
+            path: "../templates/opinionated/module.tpl",
+            data: {
+                className,
+                moduleName: (0, boost_ts_1.anyCaseToPascalCase)(moduleName),
+                path,
+            },
+        },
+    });
+}

package/bin/help/cli.d.ts

@@ -0,0 +1,4 @@
+import { CommandModule } from "yargs";
+type CommandModuleArgs = {};
+declare const helpCommand: () => CommandModule<CommandModuleArgs, any>;
+export { helpCommand };

package/bin/help/cli.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.helpCommand = void 0;
+const form_1 = require("./form");
+const helpCommand = () => {
+    return {
+        command: "resources",
+        describe: "Resource list",
+        aliases: ["r"],
+        handler: async () => {
+            await (0, form_1.helpForm)();
+        },
+    };
+};
+exports.helpCommand = helpCommand;

package/bin/help/form.d.ts

@@ -0,0 +1,2 @@
+declare const helpForm: () => Promise<void>;
+export { helpForm };

package/bin/help/form.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.helpForm = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const helpForm = async () => {
+    const table = new cli_table3_1.default({
+        head: [
+            chalk_1.default.green("Name"),
+            chalk_1.default.green("Alias"),
+            chalk_1.default.green("Description"),
+        ],
+        colWidths: [15, 10, 60],
+    });
+    table.push(["new project", "new", "Generate a new project"], ["info", "i", "Provides project information"], ["resources", "r", "Displays cli commands and resources"], ["help", "h", "Show command help"], [
+        "service",
+        "g s",
+        "Generate a service [controller, usecase, dto, module]",
+    ], ["controller", "g c", "Generate a controller"], ["usecase", "g u", "Generate a usecase"], ["dto", "g d", "Generate a dto"], ["entity", "g e", "Generate an entity"], ["provider", "g p", "Generate a provider"], ["module", "g mo", "Generate a module"], ["middleware", "g mi", "Generate a middleware"]);
+    console.log(chalk_1.default.bold.white("ExpressoTS:", `${chalk_1.default.green("Resources List")}`));
+    console.log(chalk_1.default.whiteBright(table.toString()));
+    console.log(chalk_1.default.bold.white(`📝 More info: ${chalk_1.default.green("https://doc.expresso-ts.com/docs/category/cli")}`));
+    console.log("\n");
+};
+exports.helpForm = helpForm;

package/bin/help/index.d.ts

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

package/bin/help/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/bin/info/form.d.ts

@@ -1,2 +1,2 @@
-declare const infoForm: () => Promise<void>;
+declare const infoForm: () => void;
 export { infoForm };

package/bin/info/form.js

@@ -8,7 +8,6 @@ const chalk_1 = __importDefault(require("chalk"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
-const cli_1 = require("../cli");
 const cli_ui_1 = require("../utils/cli-ui");
 function getInfosFromPackage() {
     try {
@@ -19,21 +18,19 @@ function getInfosFromPackage() {
         const fileContents = fs_1.default.readFileSync(packageJsonPath, "utf-8");
         const packageJson = JSON.parse(fileContents);
         console.log(chalk_1.default.green("ExpressoTS Project:"));
-        console.log(chalk_1.default.bold(`\tName: ${packageJson.name}`));
-        console.log(chalk_1.default.bold(`\tDescription: ${packageJson.description}`));
-        console.log(chalk_1.default.bold(`\tVersion: ${packageJson.version}`));
-        console.log(chalk_1.default.bold(`\tAuthor: ${packageJson.author}`));
+        console.log(chalk_1.default.white(`\tName: ${packageJson.name}`));
+        console.log(chalk_1.default.white(`\tDescription: ${packageJson.description}`));
+        console.log(chalk_1.default.white(`\tVersion: ${packageJson.version}`));
+        console.log(chalk_1.default.white(`\tAuthor: ${packageJson.author}`));
     }
     catch (error) {
         (0, cli_ui_1.printError)("No project information available.", "package.json not found!");
     }
 }
-const infoForm = async () => {
-    console.log(chalk_1.default.green("System informations:"));
-    console.log(chalk_1.default.bold(`\tOS Version: ${os_1.default.version()}`));
-    console.log(chalk_1.default.bold(`\tNodeJS version: ${process.version}`));
-    console.log(chalk_1.default.green("CLI Version:"));
-    console.log(chalk_1.default.bold(`\tCurrent version: v${cli_1.CLI_VERSION}`));
+const infoForm = () => {
     getInfosFromPackage();
+    console.log(chalk_1.default.green("System information:"));
+    console.log(chalk_1.default.white(`\tOS Version: ${os_1.default.version()}`));
+    console.log(chalk_1.default.white(`\tNodeJS version: ${process.version}`));
 };
 exports.infoForm = infoForm;

package/bin/new/form.js

@@ -166,6 +166,7 @@ const projectForm = async (projectName, args) => {
             await emitter.clone(answer.name);
         }
         catch (err) {
+            console.log("\n");
             (0, cli_ui_1.printError)("Project already exists or Folder is not empty", answer.name);
             process.exit(1);
         }

package/bin/utils/add-controller-to-module.d.ts

@@ -1,2 +1 @@
-declare function addControllerToModule(filePath: string, controllerName: string, controllerPath: string): Promise<void>;
-export { addControllerToModule };
+export declare function addControllerToModule(filePath: string, controllerName: string, controllerPath: string): Promise<void>;

package/bin/utils/add-module-to-container.d.ts

@@ -1,2 +1,3 @@
 declare function addModuleToContainer(name: string, modulePath?: string, path?: string): Promise<void>;
-export { addModuleToContainer };
+declare function addModuleToContainerNestedPath(name: string, path?: string): Promise<void>;
+export { addModuleToContainer, addModuleToContainerNestedPath };

package/bin/utils/add-module-to-container.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addModuleToContainer = void 0;
+exports.addModuleToContainerNestedPath = exports.addModuleToContainer = void 0;
 const chalk_1 = __importDefault(require("chalk"));
 const glob_1 = require("glob");
 const node_fs_1 = __importDefault(require("node:fs"));
@@ -67,14 +67,14 @@ async function addModuleToContainer(name, modulePath, path) {
     const modulePathRegex = /^[^/]=$/;
     if (!modulePathRegex.test(modulePath)) {
         if (path.split("/").length > 1) {
-            newImport = `import { ${moduleName}Module } from "${usecaseDir}${modulePath}/${name}.module";`;
+            newImport = `import { ${moduleName}Module } from "${usecaseDir}${name.toLowerCase()}/${name.toLowerCase()}.module";`;
         }
         else {
-            newImport = `import { ${moduleName}Module } from "${usecaseDir}${name}.module";`;
+            newImport = `import { ${moduleName}Module } from "${usecaseDir}${name.toLowerCase()}.module";`;
         }
     }
     else {
-        newImport = `import { ${moduleName}Module } from "${usecaseDir}${name}/${name}.module";`;
+        newImport = `import { ${moduleName}Module } from "${usecaseDir}${name}/${name.toLowerCase()}.module";`;
     }
     if (containerData.imports.includes(newImport) &&
         containerData.modules.includes(`${moduleName}Module`)) {
@@ -94,3 +94,36 @@ async function addModuleToContainer(name, modulePath, path) {
     await node_fs_1.default.promises.writeFile(containerData.path, newFileContent, "utf8");
 }
 exports.addModuleToContainer = addModuleToContainer;
+async function addModuleToContainerNestedPath(name, path) {
+    const containerData = await validateAppContainer();
+    const moduleName = (name[0].toUpperCase() + name.slice(1)).trimStart();
+    const { opinionated } = await compiler_1.default.loadConfig();
+    let usecaseDir;
+    if (opinionated) {
+        usecaseDir = `@useCases/`;
+    }
+    else {
+        usecaseDir = `./`;
+    }
+    if (path.endsWith("/")) {
+        path = path.slice(0, -1);
+    }
+    const newImport = `import { ${moduleName}Module } from "${usecaseDir}${path}.module";`;
+    if (containerData.imports.includes(newImport) &&
+        containerData.modules.includes(`${moduleName}Module`)) {
+        return;
+    }
+    containerData.imports.push(newImport);
+    containerData.modules.push(`${moduleName}Module`);
+    const newModule = containerData.modules.join(", ");
+    const newModuleDeclaration = `.create([${newModule}]`;
+    const newFileContent = [
+        ...containerData.imports,
+        ...containerData.notImports,
+    ]
+        .join("\n")
+        .replace(containerData.regex, newModuleDeclaration);
+    console.log(" ", chalk_1.default.greenBright(`[container]`.padEnd(14)), chalk_1.default.bold.white(`${moduleName}Module added to ${APP_CONTAINER}! ✔️`));
+    await node_fs_1.default.promises.writeFile(containerData.path, newFileContent, "utf8");
+}
+exports.addModuleToContainerNestedPath = addModuleToContainerNestedPath;

package/bin/utils/cli-ui.d.ts

@@ -1 +1,3 @@
 export declare function printError(message: string, component: string): void;
+export declare function printGenerateError(schematic: string, file: string): Promise<void>;
+export declare function printGenerateSuccess(schematic: string, file: string): Promise<void>;