opticore-feature-component 1.0.0

package/dist/index.cjs

@@ -0,0 +1,2243 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/utils/welcomeMessage.utils.ts
+function UWelcomeMessage() {
+  return console.log((0, import_gradient_string.default)("cyan", "pink", "orange")(
+    "\u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E\n\u2502                                                    \u2502\n\u2502          Welcome to Feature Component CLI          \u2502\n\u2502                                                    \u2502\n\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F\n"
+  ));
+}
+var import_gradient_string;
+var init_welcomeMessage_utils = __esm({
+  "src/utils/welcomeMessage.utils.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_gradient_string = __toESM(require("gradient-string"), 1);
+  }
+});
+
+// src/utils/fsModule.utils.ts
+var import_fs, UFsModule;
+var init_fsModule_utils = __esm({
+  "src/utils/fsModule.utils.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_fs = __toESM(require("fs"), 1);
+    UFsModule = class {
+      static createDirectoryRecursively(dirPath) {
+        try {
+          import_fs.default.mkdirSync(dirPath, { recursive: true });
+        } catch (e) {
+          console.error(e.message);
+        }
+      }
+      static createFile(filePath, fileContent) {
+        try {
+          import_fs.default.writeFileSync(filePath, fileContent);
+        } catch (e) {
+          console.error(e.message);
+        }
+      }
+      static removeDir(directory, recursive, force) {
+        try {
+          if (import_fs.default.existsSync(directory)) {
+            import_fs.default.rmSync(directory, { recursive, force });
+          }
+        } catch (e) {
+          console.error(`Error removing folder: ${e.message}`, e);
+          process.exit(0);
+        }
+      }
+    };
+  }
+});
+
+// src/utils/prompt.utils.ts
+var import_prompts, import_ansi_colors, import_opticore_logger, import_opticore_http_response, UPrompt;
+var init_prompt_utils = __esm({
+  "src/utils/prompt.utils.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_prompts = require("@clack/prompts");
+    import_ansi_colors = __toESM(require("ansi-colors"), 1);
+    init_fsModule_utils();
+    import_opticore_logger = require("opticore-logger");
+    import_opticore_http_response = require("opticore-http-response");
+    UPrompt = class {
+      static logger = new import_opticore_logger.LoggerCore();
+      static async text(message, placeholder, validate) {
+        return await (0, import_prompts.text)(
+          {
+            message,
+            placeholder,
+            validate
+          }
+        );
+      }
+      static async confirm(message, defaultValue = true) {
+        return await (0, import_prompts.confirm)({
+          message,
+          initialValue: defaultValue
+        });
+      }
+      static cancelOperation(controllerPath) {
+        console.log(`${import_ansi_colors.default.bgRed(`${import_ansi_colors.default.white("Operation cancelled.")}`)}`);
+        if (controllerPath) {
+          try {
+            UFsModule.removeDir(controllerPath, true, true);
+            this.logger.info({
+              title: "DIR_REMOVED",
+              message: `Removed controller directory: ${controllerPath}`
+            });
+          } catch (error) {
+            this.logger.error({
+              errorType: error.name,
+              httpCodeValue: import_opticore_http_response.HttpStatusCode.INTERNAL_SERVER_ERROR,
+              message: error.message,
+              stackTrace: error.stack,
+              title: "FAILED_TO_REMOVE_CONTROLLER_DIR"
+            });
+          }
+        }
+        process.exit(0);
+      }
+      static async select(message, defaultValue, options) {
+        let optSelected = await (0, import_prompts.select)({
+          message,
+          initialValue: defaultValue,
+          options
+        });
+        return optSelected[0];
+      }
+    };
+  }
+});
+
+// src/utils/choiceFeatureCleanModule.ts
+async function choiceFeatureCleanModule() {
+  const featureSelected = await UPrompt.select(
+    "Please choose the creation principle for your feature :",
+    ["opticore_principle"],
+    [
+      { label: "OptiCoreJs CLEAN Module", value: ["opticore_clean_module"], hint: "recommended" },
+      { label: "Custom feature", value: ["custom_feature"] }
+    ]
+  );
+  if ((0, import_prompts2.isCancel)(featureSelected)) {
+    console.log(`${import_ansi_colors2.default.bgRed(`${import_ansi_colors2.default.white("Operation cancelled.")}`)}`);
+    process.exit(0);
+  } else {
+    return featureSelected;
+  }
+}
+var import_ansi_colors2, import_prompts2;
+var init_choiceFeatureCleanModule = __esm({
+  "src/utils/choiceFeatureCleanModule.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_ansi_colors2 = __toESM(require("ansi-colors"), 1);
+    import_prompts2 = require("@clack/prompts");
+    init_prompt_utils();
+  }
+});
+
+// src/utils/constants/customFeatureInfoMessage.constant.ts
+function customFeatureInfo() {
+  console.log(`${import_ansi_colors3.default.bgCyan(`${import_ansi_colors3.default.white("\nYou will have to create and configure your created modules manually.")}`)}`);
+  import_process.default.exit(0);
+}
+var import_ansi_colors3, import_process;
+var init_customFeatureInfoMessage_constant = __esm({
+  "src/utils/constants/customFeatureInfoMessage.constant.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_ansi_colors3 = __toESM(require("ansi-colors"), 1);
+    import_process = __toESM(require("process"), 1);
+  }
+});
+
+// src/utils/customFeatureInfo.utils.ts
+function UCustomFeatureInfo(choice) {
+  console.log(`You have chosen : ${choice === "opticore_clean_module" ? import_ansi_colors4.default.cyan("OptiCoreJs CLEAN Module") : import_ansi_colors4.default.cyan("Custom feature")} 
+`);
+  console.log(`Clean module contains the following files :`);
+  console.log(`${import_ansi_colors4.default.cyan("application")}`);
+  console.log(`     \u2570\u2500\u2500${import_ansi_colors4.default.bgBlackBright(`${import_ansi_colors4.default.white("{controller, service, validator}")}`)}`);
+  console.log(`${import_ansi_colors4.default.cyan("domain")}`);
+  console.log(`     \u2570\u2500\u2500${import_ansi_colors4.default.bgBlackBright(`${import_ansi_colors4.default.white("{constants, entities, enums, interfaces}")}`)}`);
+  console.log(`${import_ansi_colors4.default.cyan("infrastructures")}`);
+  console.log(`     \u2570\u2500\u2500${import_ansi_colors4.default.bgBlackBright(`${import_ansi_colors4.default.white("{api, middleware}")}`)}`);
+  console.log(`${import_ansi_colors4.default.cyan("persistence")}`);
+  console.log(`     \u2570\u2500\u2500${import_ansi_colors4.default.bgBlackBright(`${import_ansi_colors4.default.white("{cache, contrats, repositories, usecases}")}`)}`);
+  console.log(`${import_ansi_colors4.default.cyan("file")} : route of feature named ${import_ansi_colors4.default.cyan("featureName.router")} 
+`);
+  console.log(import_ansi_colors4.default.cyan("Now let's start create a feature !"));
+}
+var import_ansi_colors4;
+var init_customFeatureInfo_utils = __esm({
+  "src/utils/customFeatureInfo.utils.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_ansi_colors4 = __toESM(require("ansi-colors"), 1);
+  }
+});
+
+// src/services/featureName.service.ts
+var _featureName;
+var init_featureName_service = __esm({
+  "src/services/featureName.service.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_prompt_utils();
+    _featureName = async () => {
+      return await UPrompt.text(
+        "Enter feature's name :",
+        "login",
+        (value) => {
+          let pattern = new RegExp("^[a-z][A-Za-z]+$");
+          if (!value) {
+            return "Please enter a feature's name.";
+          }
+          if (!pattern.test(value)) {
+            return "Please enter a valide feature's name.";
+          }
+        }
+      );
+    };
+  }
+});
+
+// src/services/base.service.ts
+var import_path, import_node_fs, import_ansi_colors5, import_process2, BaseService;
+var init_base_service = __esm({
+  "src/services/base.service.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_path = __toESM(require("path"), 1);
+    import_node_fs = __toESM(require("fs"), 1);
+    import_ansi_colors5 = __toESM(require("ansi-colors"), 1);
+    import_process2 = __toESM(require("process"), 1);
+    init_fsModule_utils();
+    BaseService = class {
+      static _isSubdirectoryExists(subdirectory) {
+        const subdirectoryString = typeof subdirectory === "symbol" ? subdirectory.toString() : String(subdirectory);
+        const subdirectoryPath = import_path.default.join(import_process2.default.cwd(), "src", "features", subdirectoryString);
+        try {
+          const stats = import_node_fs.default.statSync(subdirectoryPath);
+          return stats.isDirectory();
+        } catch (error) {
+          return false;
+        }
+      }
+      static _featureFounded(feature) {
+        console.log(`${import_ansi_colors5.default.bgCyan(`${import_ansi_colors5.default.white(`${import_ansi_colors5.default.bold(`feature ${feature} is already exists.`)}`)}`)}`);
+        import_process2.default.exit(0);
+      }
+      static _checkFeatureDir() {
+        console.error(`${import_ansi_colors5.default.bgRed(`${import_ansi_colors5.default.white("Check if directory src/features exists, and try again.")}`)}`);
+        import_process2.default.exit();
+      }
+      static _dirFounded(feature) {
+        console.error(`${import_ansi_colors5.default.bgRed(`${import_ansi_colors5.default.white(`The ${import_ansi_colors5.default.bgCyan(`${import_ansi_colors5.default.bold(`feature ${feature} is already exists.`)}`)}`)}`)}`);
+        import_process2.default.exit();
+      }
+      static _cancelOperation(controllerPath) {
+        console.log(`${import_ansi_colors5.default.bgRed(`${import_ansi_colors5.default.white("Operation cancelled.")}`)}`);
+        UFsModule.removeDir(controllerPath, true, true);
+        import_process2.default.exit(0);
+      }
+      static async _createFeatureModuleDir(featureDir, feature) {
+        let ora = (await import("ora")).default;
+        const spinner = ora("Feature's name creation...").start();
+        UFsModule.createDirectoryRecursively(featureDir);
+        spinner.succeed(`Your feature"s name ${import_ansi_colors5.default.bgCyan(import_ansi_colors5.default.white(`${feature}`))} has been created successfully. 
+`);
+        return { featureDir, feature };
+      }
+      static async _createApplicationDirComponent(feature) {
+        let application = "";
+        application = `${feature}/application`;
+        UFsModule.createDirectoryRecursively(application);
+        return application;
+      }
+      static async _createDomainDirComponent(feature) {
+        let domain = "";
+        domain = `${feature}/domain`;
+        UFsModule.createDirectoryRecursively(domain);
+        return domain;
+      }
+      static async _createInfraDirComponent(feature) {
+        let infrastructure = "";
+        infrastructure = `${feature}/infrastructure`;
+        UFsModule.createDirectoryRecursively(infrastructure);
+        return infrastructure;
+      }
+      static async _createPersistenceDirComponent(feature) {
+        let persistence = "";
+        persistence = `${feature}/persistence`;
+        UFsModule.createDirectoryRecursively(persistence);
+        return persistence;
+      }
+    };
+  }
+});
+
+// src/services/controllerType.service.ts
+async function _controllerType(messageText, defaultValue, options) {
+  return await UPrompt.select(
+    messageText,
+    [defaultValue],
+    options
+  );
+}
+var init_controllerType_service = __esm({
+  "src/services/controllerType.service.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_prompt_utils();
+  }
+});
+
+// src/core/domains/constants/cleanType.constant.ts
+var CCleanType;
+var init_cleanType_constant = __esm({
+  "src/core/domains/constants/cleanType.constant.ts"() {
+    "use strict";
+    init_cjs_shims();
+    CCleanType = {
+      "clean_component_by_step": "clean_component_by_step",
+      "full_clean_component": "full_clean_component",
+      "simple_component": "simple_component"
+    };
+  }
+});
+
+// src/templates/cleanComponents/controller.template.ts
+var generateControllerTemplate, generateMethod, generateFindAllMethod, generateFindByIdMethod, generateCreateMethod, generateUpdateMethod, generateDeleteMethod, errorHandlerAppend, capitalize;
+var init_controller_template = __esm({
+  "src/templates/cleanComponents/controller.template.ts"() {
+    "use strict";
+    init_cjs_shims();
+    generateControllerTemplate = (controllerName, featureName, methods) => {
+      const capitalized = capitalize(featureName);
+      const useCaseName = `${capitalized}UseCase`;
+      const presenterName = `${capitalized}Presenter`;
+      const methodsCode = methods.map((method) => generateMethod(method, featureName, capitalized)).join("\n");
+      const errorHandler = errorHandlerAppend(capitalized);
+      return `import { Request, Response } from "express";
+import { ResponseHandler, HttpStatusCode, IResponseHandlerSuccessData } from "opticore-http-response";
+import { ${useCaseName} } from "../../../application/use-cases/${featureName}.usecase";
+import { ${presenterName} } from "../presenters/${featureName}.presenter";
+import { ${capitalized}Repository } from "../repositories/${featureName}.repository";
+
+/**
+ * ${controllerName} \u2014 HTTP Controller (Infrastructure Layer)
+ *
+ * Handles Express Request/Response only.
+ * Delegates all business logic to the use case.
+ * Uses the presenter to format the output.
+ *
+ * Wiring: Controller \u2192 UseCase \u2192 Repository (all injected here manually).
+ * For larger projects, replace manual wiring with a DI container (e.g., tsyringe, awilix).
+ */
+export class ${controllerName} {
+    private static buildUseCase(): ${useCaseName} {
+        const repository = new ${capitalized}Repository();
+        return new ${useCaseName}(repository);
+    }
+
+    private static buildPresenter(): ${presenterName} {
+        return new ${presenterName}();
+    }
+
+${methodsCode}
+${errorHandler}
+}
+`;
+    };
+    generateMethod = (method, featureName, capitalized) => {
+      const lower = method.toLowerCase();
+      if (lower.includes("findall") || lower.includes("getall")) {
+        return generateFindAllMethod(method, featureName, capitalized);
+      }
+      if (lower.includes("findbyid") || lower.includes("getbyid") || lower.includes("getone")) {
+        return generateFindByIdMethod(method, featureName, capitalized);
+      }
+      if (lower.includes("create") || lower.includes("add")) {
+        return generateCreateMethod(method, featureName, capitalized);
+      }
+      if (lower.includes("update") || lower.includes("edit")) {
+        return generateUpdateMethod(method, featureName, capitalized);
+      }
+      if (lower.includes("delete") || lower.includes("remove")) {
+        return generateDeleteMethod(method, featureName, capitalized);
+      }
+      return `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const useCase = ${capitalized}Controller.buildUseCase();
+            const presenter = ${capitalized}Controller.buildPresenter();
+            // TODO: Implement ${method} logic
+            // const result = await useCase.${method}(...);
+            return ResponseHandler.success(presenter.presentOne({} as any), "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+    };
+    generateFindAllMethod = (method, featureName, capitalized) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const useCase = ${capitalized}Controller.buildUseCase();
+            const presenter = ${capitalized}Controller.buildPresenter();
+
+            const results = await useCase.findAll();
+            return ResponseHandler.success(presenter.presentMany(results), "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+    generateFindByIdMethod = (method, featureName, capitalized) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const { id } = req.params;
+            const useCase = ${capitalized}Controller.buildUseCase();
+            const presenter = ${capitalized}Controller.buildPresenter();
+
+            const result = await useCase.findById(id);
+            if (!result) {
+                return ResponseHandler.error(\`Not found: \${id}\`, HttpStatusCode.NOT_FOUND);
+            }
+            return ResponseHandler.success(presenter.presentOne(result), "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+    generateCreateMethod = (method, featureName, capitalized) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const dto = req.body; // TODO: Validate with your validation layer
+            const useCase = ${capitalized}Controller.buildUseCase();
+            const presenter = ${capitalized}Controller.buildPresenter();
+
+            const result = await useCase.create(dto);
+            return ResponseHandler.success(presenter.presentOne(result), "created", HttpStatusCode.CREATED);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+    generateUpdateMethod = (method, featureName, capitalized) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const { id } = req.params;
+            const dto = { ...req.body, id }; // TODO: Validate with your validation layer
+            const useCase = ${capitalized}Controller.buildUseCase();
+            const presenter = ${capitalized}Controller.buildPresenter();
+
+            const result = await useCase.update(dto);
+            if (!result) {
+                return ResponseHandler.error(\`Not found: \${id}\`, HttpStatusCode.NOT_FOUND);
+            }
+            return ResponseHandler.success(presenter.presentOne(result), "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+    generateDeleteMethod = (method, featureName, capitalized) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const { id } = req.params;
+            const useCase = ${capitalized}Controller.buildUseCase();
+
+            const deleted = await useCase.delete(id);
+            if (!deleted) {
+                return ResponseHandler.error(\`Not found: \${id}\`, HttpStatusCode.NOT_FOUND);
+            }
+            return ResponseHandler.success(null, "deleted", HttpStatusCode.NO_CONTENT);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+    errorHandlerAppend = (capitalized) => `
+    private static handleError(error: unknown) {
+        const message = error instanceof Error ? error.message : "Internal server error";
+        return ResponseHandler.error(message, HttpStatusCode.INTERNAL_SERVER_ERROR);
+    }
+`;
+    capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+  }
+});
+
+// src/templates/cleanComponents/entity.template.ts
+var generateEntityTemplate, capitalize2;
+var init_entity_template = __esm({
+  "src/templates/cleanComponents/entity.template.ts"() {
+    "use strict";
+    init_cjs_shims();
+    generateEntityTemplate = (entityName, featureName) => {
+      const capitalized = capitalize2(featureName);
+      return `/**
+ * ${entityName} \u2014 Domain Entity
+ * Represents the core business object for the "${featureName}" feature.
+ * No framework dependency, pure business logic only.
+ */
+export class ${entityName} {
+    private readonly _id: string;
+    private _createdAt: Date;
+    private _updatedAt: Date;
+
+    constructor(
+        id: string,
+        // TODO: Add your business properties here
+        createdAt?: Date,
+        updatedAt?: Date,
+    ) {
+        this._id = id;
+        this._createdAt = createdAt ?? new Date();
+        this._updatedAt = updatedAt ?? new Date();
+
+        this.validate();
+    }
+
+    // -------------------------------------------------------------------------
+    // Getters
+    // -------------------------------------------------------------------------
+
+    get id(): string {
+        return this._id;
+    }
+
+    get createdAt(): Date {
+        return this._createdAt;
+    }
+
+    get updatedAt(): Date {
+        return this._updatedAt;
+    }
+
+    // -------------------------------------------------------------------------
+    // Business methods (behavior belongs to the entity)
+    // -------------------------------------------------------------------------
+
+    /**
+     * Marks the entity as updated.
+     * Call this whenever a business mutation occurs.
+     */
+    public touch(): void {
+        this._updatedAt = new Date();
+    }
+
+    /**
+     * Returns a plain object snapshot of the entity.
+     * Useful for persistence or presentation mapping.
+     */
+    public toSnapshot(): Record<string, unknown> {
+        return {
+            id: this._id,
+            createdAt: this._createdAt,
+            updatedAt: this._updatedAt,
+        };
+    }
+
+    // -------------------------------------------------------------------------
+    // Invariant validation (domain rules enforced at construction)
+    // -------------------------------------------------------------------------
+
+    private validate(): void {
+        if (!this._id || this._id.trim().length === 0) {
+            throw new Error(\`[${entityName}] id must not be empty.\`);
+        }
+        // TODO: Add your domain invariant checks here
+    }
+}
+`;
+    };
+    capitalize2 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+  }
+});
+
+// src/templates/cleanComponents/repositoryInterface.template.ts
+var generateRepositoryInterfaceTemplate, capitalize3;
+var init_repositoryInterface_template = __esm({
+  "src/templates/cleanComponents/repositoryInterface.template.ts"() {
+    "use strict";
+    init_cjs_shims();
+    generateRepositoryInterfaceTemplate = (interfaceName, featureName) => {
+      const entityName = `${capitalize3(featureName)}Entity`;
+      const entityImport = `../../../domain/entities/${featureName}.entity`;
+      return `import { ${entityName} } from "${entityImport}";
+
+/**
+ * ${interfaceName} \u2014 Repository Port (Application Layer)
+ *
+ * Defines the persistence contract. The infrastructure layer must implement this.
+ * The application layer depends on this abstraction \u2014 never on a concrete ORM or DB.
+ */
+export interface ${interfaceName} {
+
+    /**
+     * Returns all ${featureName} entities.
+     */
+    findAll(): Promise<${entityName}[]>;
+
+    /**
+     * Finds a single ${featureName} by its unique identifier.
+     * Returns null if not found (avoid throwing for "not found" in repositories).
+     */
+    findById(id: string): Promise<${entityName} | null>;
+
+    /**
+     * Persists a new ${featureName} entity.
+     * Returns the created entity (with generated id if applicable).
+     */
+    create(entity: ${entityName}): Promise<${entityName}>;
+
+    /**
+     * Persists changes to an existing ${featureName} entity.
+     * Returns the updated entity, or null if not found.
+     */
+    update(entity: ${entityName}): Promise<${entityName} | null>;
+
+    /**
+     * Removes a ${featureName} entity by id.
+     * Returns true if deleted, false if not found.
+     */
+    delete(id: string): Promise<boolean>;
+}
+`;
+    };
+    capitalize3 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+  }
+});
+
+// src/templates/cleanComponents/repositoryImpl.template.ts
+var generateRepositoryImplTemplate, capitalize4;
+var init_repositoryImpl_template = __esm({
+  "src/templates/cleanComponents/repositoryImpl.template.ts"() {
+    "use strict";
+    init_cjs_shims();
+    generateRepositoryImplTemplate = (featureName, interfaceImportPath) => {
+      const capitalized = capitalize4(featureName);
+      const implName = `${capitalized}Repository`;
+      const interfaceName = `I${capitalized}Repository`;
+      const entityName = `${capitalized}Entity`;
+      const entityImport = `../../../domain/entities/${featureName}.entity`;
+      return `import { ${interfaceName} } from "${interfaceImportPath}";
+import { ${entityName} } from "${entityImport}";
+
+/**
+ * ${implName} \u2014 Repository Implementation (Infrastructure Layer)
+ *
+ * Provides the actual persistence logic for ${featureName}.
+ * Replace the in-memory store below with your ORM (TypeORM, Prisma, Mongoose, etc.).
+ * This class depends on the ${interfaceName} contract defined in the application layer.
+ */
+export class ${implName} implements ${interfaceName} {
+
+    /**
+     * TODO: Inject your database client / ORM model here via the constructor.
+     * Example with TypeORM:
+     *   constructor(private readonly repo: Repository<${capitalized}Model>) {}
+     *
+     * Example with Prisma:
+     *   constructor(private readonly prisma: PrismaClient) {}
+     */
+
+    // -------------------------------------------------------------------------
+    // In-memory store (replace with real persistence)
+    // -------------------------------------------------------------------------
+    private store: Map<string, ${entityName}> = new Map();
+
+    async findAll(): Promise<${entityName}[]> {
+        // TODO: Replace with your ORM query
+        // Example (TypeORM): return this.repo.find();
+        // Example (Prisma):  const rows = await this.prisma.${featureName}.findMany();
+        //                    return rows.map(row => this.toDomain(row));
+        return Array.from(this.store.values());
+    }
+
+    async findById(id: string): Promise<${entityName} | null> {
+        // TODO: Replace with your ORM query
+        // Example (TypeORM): return this.repo.findOneBy({ id }) ?? null;
+        // Example (Prisma):  const row = await this.prisma.${featureName}.findUnique({ where: { id } });
+        //                    return row ? this.toDomain(row) : null;
+        return this.store.get(id) ?? null;
+    }
+
+    async create(entity: ${entityName}): Promise<${entityName}> {
+        // TODO: Replace with your ORM save
+        // Example (TypeORM): const model = this.repo.create(this.toPersistence(entity));
+        //                    return this.toDomain(await this.repo.save(model));
+        // Example (Prisma):  const row = await this.prisma.${featureName}.create({ data: this.toPersistence(entity) });
+        //                    return this.toDomain(row);
+        this.store.set(entity.id, entity);
+        return entity;
+    }
+
+    async update(entity: ${entityName}): Promise<${entityName} | null> {
+        // TODO: Replace with your ORM update
+        if (!this.store.has(entity.id)) return null;
+        this.store.set(entity.id, entity);
+        return entity;
+    }
+
+    async delete(id: string): Promise<boolean> {
+        // TODO: Replace with your ORM delete
+        // Example (TypeORM): const result = await this.repo.delete(id);
+        //                    return (result.affected ?? 0) > 0;
+        return this.store.delete(id);
+    }
+
+    // -------------------------------------------------------------------------
+    // Private mappers (ORM model \u2194 Domain entity)
+    // -------------------------------------------------------------------------
+
+    /**
+     * Maps an ORM/DB row to a domain entity.
+     * TODO: Adapt field mapping to your actual persistence model.
+     */
+    private toDomain(row: any): ${entityName} {
+        return new ${entityName}(
+            row.id,
+            // TODO: Map your ORM fields here
+            row.createdAt,
+            row.updatedAt,
+        );
+    }
+
+    /**
+     * Maps a domain entity to an ORM/DB-friendly plain object.
+     * TODO: Adapt to your schema.
+     */
+    private toPersistence(entity: ${entityName}): Record<string, unknown> {
+        return {
+            id: entity.id,
+            // TODO: Map your domain fields here
+            createdAt: entity.createdAt,
+            updatedAt: entity.updatedAt,
+        };
+    }
+}
+`;
+    };
+    capitalize4 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+  }
+});
+
+// src/templates/cleanComponents/useCase.template.ts
+var generateUseCaseTemplate, capitalize5;
+var init_useCase_template = __esm({
+  "src/templates/cleanComponents/useCase.template.ts"() {
+    "use strict";
+    init_cjs_shims();
+    generateUseCaseTemplate = (useCaseName, featureName) => {
+      const capitalized = capitalize5(featureName);
+      const interfaceName = `I${capitalized}Repository`;
+      const entityName = `${capitalized}Entity`;
+      return `import { ${interfaceName} } from "../ports/repositories/${featureName}.repository.interface";
+import { ${entityName} } from "../../domain/entities/${featureName}.entity";
+import {
+    Create${capitalized}Dto,
+    Update${capitalized}Dto,
+    ${capitalized}ResponseDto,
+    ${capitalized}DtoMapper,
+} from "../dtos/${featureName}.dto";
+
+/**
+ * ${useCaseName} \u2014 Application Use Case
+ *
+ * Orchestrates business operations for the "${featureName}" feature.
+ * It depends ONLY on the repository port (interface), never on a concrete implementation.
+ * The concrete repository is injected at the infrastructure level (DI container or manual wiring).
+ */
+export class ${useCaseName} {
+
+    constructor(
+        private readonly repository: ${interfaceName},
+    ) {}
+
+    // -------------------------------------------------------------------------
+    // Query methods (read)
+    // -------------------------------------------------------------------------
+
+    async findAll(): Promise<${capitalized}ResponseDto[]> {
+        const entities = await this.repository.findAll();
+        return ${capitalized}DtoMapper.toResponseList(entities);
+    }
+
+    async findById(id: string): Promise<${capitalized}ResponseDto | null> {
+        const entity = await this.repository.findById(id);
+        if (!entity) return null;
+        return ${capitalized}DtoMapper.toResponse(entity);
+    }
+
+    // -------------------------------------------------------------------------
+    // Command methods (write)
+    // -------------------------------------------------------------------------
+
+    async create(dto: Create${capitalized}Dto): Promise<${capitalized}ResponseDto> {
+        // TODO: Map DTO to domain entity. Generate id using your preferred strategy (uuid, etc.)
+        const id = crypto.randomUUID();
+        const entity = new ${entityName}(
+            id,
+            // TODO: Pass your domain fields from dto
+        );
+
+        const saved = await this.repository.create(entity);
+        return ${capitalized}DtoMapper.toResponse(saved);
+    }
+
+    async update(dto: Update${capitalized}Dto): Promise<${capitalized}ResponseDto | null> {
+        const existing = await this.repository.findById(dto.id);
+        if (!existing) return null;
+
+        // TODO: Apply the update to the domain entity
+        // existing.updateName(dto.name);
+        existing.touch();
+
+        const updated = await this.repository.update(existing);
+        if (!updated) return null;
+        return ${capitalized}DtoMapper.toResponse(updated);
+    }
+
+    async delete(id: string): Promise<boolean> {
+        return this.repository.delete(id);
+    }
+}
+`;
+    };
+    capitalize5 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+  }
+});
+
+// src/templates/cleanComponents/dto.template.ts
+var generateDtoTemplate, capitalize6;
+var init_dto_template = __esm({
+  "src/templates/cleanComponents/dto.template.ts"() {
+    "use strict";
+    init_cjs_shims();
+    generateDtoTemplate = (featureName) => {
+      const capitalized = capitalize6(featureName);
+      return `/**
+ * ${capitalized}Dto \u2014 Data Transfer Objects (Application Layer)
+ *
+ * DTOs define the shape of data entering and leaving use cases.
+ * They decouple the domain model from HTTP requests/responses.
+ * Validation is handled at the infrastructure layer (e.g., in the controller).
+ */
+
+// -------------------------------------------------------------------------
+// Input DTOs (data coming IN to use cases)
+// -------------------------------------------------------------------------
+
+export interface Create${capitalized}Dto {
+    // TODO: Define the fields required to create a ${featureName}
+    // Example:
+    // name: string;
+    // email: string;
+}
+
+export interface Update${capitalized}Dto {
+    id: string;
+    // TODO: Define the fields allowed to be updated
+    // All fields should be optional (partial update pattern)
+    // Example:
+    // name?: string;
+}
+
+// -------------------------------------------------------------------------
+// Output DTOs (data going OUT from use cases to the controller/presenter)
+// -------------------------------------------------------------------------
+
+export interface ${capitalized}ResponseDto {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    // TODO: Mirror the fields you expose to clients
+    // Avoid leaking internal domain model details (e.g., private fields, passwords)
+}
+
+// -------------------------------------------------------------------------
+// Mapper helper (Domain Entity \u2192 Response DTO)
+// -------------------------------------------------------------------------
+
+import { ${capitalized}Entity } from "../../domain/entities/${featureName}.entity";
+
+export class ${capitalized}DtoMapper {
+
+    /**
+     * Maps a domain entity to a safe response DTO.
+     * Use this in your presenter or use case output.
+     */
+    static toResponse(entity: ${capitalized}Entity): ${capitalized}ResponseDto {
+        return {
+            id: entity.id,
+            createdAt: entity.createdAt,
+            updatedAt: entity.updatedAt,
+            // TODO: Map your additional fields here
+        };
+    }
+
+    /**
+     * Maps an array of entities to response DTOs.
+     */
+    static toResponseList(entities: ${capitalized}Entity[]): ${capitalized}ResponseDto[] {
+        return entities.map((entity) => this.toResponse(entity));
+    }
+}
+`;
+    };
+    capitalize6 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+  }
+});
+
+// src/templates/cleanComponents/presenter.template.ts
+var generatePresenterInterfaceTemplate, generatePresenterImplTemplate, capitalize7;
+var init_presenter_template = __esm({
+  "src/templates/cleanComponents/presenter.template.ts"() {
+    "use strict";
+    init_cjs_shims();
+    generatePresenterInterfaceTemplate = (featureName) => {
+      const capitalized = capitalize7(featureName);
+      const interfaceName = `I${capitalized}Presenter`;
+      return `import { ${capitalized}ResponseDto } from "../../dtos/${featureName}.dto";
+
+/**
+ * ${interfaceName} \u2014 Presenter Port (Application Layer)
+ *
+ * Defines how a use case result is formatted for the client.
+ * The infrastructure layer provides the concrete implementation
+ * (e.g., JSON serialization, HTTP envelopes, pagination wrappers).
+ */
+export interface ${interfaceName} {
+
+    /**
+     * Formats a single ${featureName} response.
+     */
+    presentOne(data: ${capitalized}ResponseDto): unknown;
+
+    /**
+     * Formats a list of ${featureName} responses.
+     */
+    presentMany(data: ${capitalized}ResponseDto[]): unknown;
+
+    /**
+     * Formats a "not found" response.
+     */
+    presentNotFound(id?: string): unknown;
+}
+`;
+    };
+    generatePresenterImplTemplate = (featureName) => {
+      const capitalized = capitalize7(featureName);
+      const implName = `${capitalized}Presenter`;
+      const interfaceName = `I${capitalized}Presenter`;
+      return `import { ${interfaceName} } from "../../../application/ports/presenters/${featureName}.presenter.interface";
+import { ${capitalized}ResponseDto } from "../../../application/dtos/${featureName}.dto";
+
+/**
+ * ${implName} \u2014 Presenter Implementation (Infrastructure Layer)
+ *
+ * Formats use case output into a client-facing structure.
+ * Keeps HTTP/JSON concerns OUT of the domain and application layers.
+ */
+export class ${implName} implements ${interfaceName} {
+
+    presentOne(data: ${capitalized}ResponseDto): unknown {
+        return {
+            success: true,
+            data,
+        };
+    }
+
+    presentMany(data: ${capitalized}ResponseDto[]): unknown {
+        return {
+            success: true,
+            count: data.length,
+            data,
+        };
+    }
+
+    presentNotFound(id?: string): unknown {
+        return {
+            success: false,
+            message: id
+                ? \`${capitalized} with id "\${id}" was not found.\`
+                : \`${capitalized} not found.\`,
+        };
+    }
+}
+`;
+    };
+    capitalize7 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+  }
+});
+
+// src/templates/cleanComponents/router.template.ts
+var resolveRoute, generateRouterHandlerTemplate, generateRouterTemplate, capitalize8;
+var init_router_template = __esm({
+  "src/templates/cleanComponents/router.template.ts"() {
+    "use strict";
+    init_cjs_shims();
+    resolveRoute = (methodName, featureName) => {
+      const lower = methodName.toLowerCase();
+      if (lower.includes("findall") || lower.includes("getall")) return { httpMethod: "get", path: `/${featureName}` };
+      if (lower.includes("findbyid") || lower.includes("getbyid") || lower.includes("getone")) return { httpMethod: "get", path: `/${featureName}/:id` };
+      if (lower.includes("create") || lower.includes("add")) return { httpMethod: "post", path: `/${featureName}` };
+      if (lower.includes("update") || lower.includes("edit")) return { httpMethod: "put", path: `/${featureName}/:id` };
+      if (lower.includes("delete") || lower.includes("remove")) return { httpMethod: "delete", path: `/${featureName}/:id` };
+      return { httpMethod: "get", path: `/${featureName}/${lower}` };
+    };
+    generateRouterHandlerTemplate = (featureName, controllerMethods) => {
+      const capitalized = capitalize8(featureName);
+      const handlerName = `${capitalized}HandlerRouter`;
+      const controllerName = `${capitalized}Controller`;
+      const routesCode = (controllerMethods || []).map((method) => {
+        const { httpMethod, path: path7 } = resolveRoute(method, featureName);
+        return `{
+    path: \`${path7}\`,
+    method: "${httpMethod}",
+    middlewares: [],
+    handler: async (ctx: ICustomContext) => await ${controllerName}.${method}(ctx.req, ctx.res)
+}`;
+      }).join(",\n");
+      return `import { OpticoreRouting, ICustomContext, IMultipleRouteDefinition } from "opticore-router";
+import { ${controllerName} } from "../adapters/controllers/${featureName}.controller";
+
+export const ${handlerName}: () => IMultipleRouteDefinition = () => {
+    return OpticoreRouting.routes(
+        ${controllerName},
+        [
+            ${routesCode.replace(/\n/g, "\n            ")}
+        ]
+    );
+};
+`;
+    };
+    generateRouterTemplate = (featureName) => {
+      const capitalized = capitalize8(featureName);
+      const handlerName = `${capitalized}HandlerRouter`;
+      const routerName = `${capitalized}Router`;
+      return `import { ${handlerName} } from "./${featureName}.router.handler";
+import { TFeatureRoutes } from "opticore-router";
+
+export const ${routerName}: TFeatureRoutes = {
+    routes: [
+        {
+            path: ${handlerName}().path,
+            handler: ${handlerName}().handler
+        }
+    ]
+};
+`;
+    };
+    capitalize8 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+  }
+});
+
+// src/templates/cleanComponents/event.template.ts
+var generateEventTemplate, capitalize9;
+var init_event_template = __esm({
+  "src/templates/cleanComponents/event.template.ts"() {
+    "use strict";
+    init_cjs_shims();
+    generateEventTemplate = (featureName) => {
+      const capitalized = capitalize9(featureName);
+      return `/**
+ * ${capitalized}Event \u2014 Domain Events
+ *
+ * Domain events capture facts that happened in the domain.
+ * They are immutable, named in the past tense, and carry the data
+ * that was relevant at the moment the event occurred.
+ *
+ * Use cases:
+ *  - Trigger side effects (send email, notify another bounded context)
+ *  - Feed an event bus / message broker (RabbitMQ, Kafka, etc.)
+ *  - Build an audit log or event sourcing stream
+ */
+
+// -------------------------------------------------------------------------
+// Base interface \u2014 all domain events share these fields
+// -------------------------------------------------------------------------
+
+export interface IDomainEvent {
+    /** Unique event identifier (uuid) */
+    readonly eventId: string;
+    /** When the event occurred */
+    readonly occurredAt: Date;
+    /** The aggregate that emitted this event */
+    readonly aggregateId: string;
+}
+
+// -------------------------------------------------------------------------
+// Concrete events for the "${featureName}" feature
+// -------------------------------------------------------------------------
+
+export class ${capitalized}CreatedEvent implements IDomainEvent {
+    readonly eventId: string;
+    readonly occurredAt: Date;
+    readonly aggregateId: string;
+
+    constructor(
+        aggregateId: string,
+        // TODO: Add the fields that describe what was created
+    ) {
+        this.eventId = crypto.randomUUID();
+        this.occurredAt = new Date();
+        this.aggregateId = aggregateId;
+    }
+}
+
+export class ${capitalized}UpdatedEvent implements IDomainEvent {
+    readonly eventId: string;
+    readonly occurredAt: Date;
+    readonly aggregateId: string;
+
+    constructor(
+        aggregateId: string,
+        // TODO: Add the fields that changed
+    ) {
+        this.eventId = crypto.randomUUID();
+        this.occurredAt = new Date();
+        this.aggregateId = aggregateId;
+    }
+}
+
+export class ${capitalized}DeletedEvent implements IDomainEvent {
+    readonly eventId: string;
+    readonly occurredAt: Date;
+    readonly aggregateId: string;
+
+    constructor(aggregateId: string) {
+        this.eventId = crypto.randomUUID();
+        this.occurredAt = new Date();
+        this.aggregateId = aggregateId;
+    }
+}
+`;
+    };
+    capitalize9 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+  }
+});
+
+// src/templates/cleanComponents/exception.template.ts
+var generateExceptionTemplate, capitalize10;
+var init_exception_template = __esm({
+  "src/templates/cleanComponents/exception.template.ts"() {
+    "use strict";
+    init_cjs_shims();
+    generateExceptionTemplate = (featureName) => {
+      const capitalized = capitalize10(featureName);
+      return `/**
+ * ${capitalized}Exception \u2014 Domain Exceptions
+ *
+ * Domain exceptions represent violations of business rules specific to "${featureName}".
+ * They are thrown inside the domain or use case layer and caught at the infrastructure
+ * layer (controller) to be translated into appropriate HTTP responses.
+ *
+ * Rule: never import HTTP status codes or Express here \u2014 this is pure domain logic.
+ */
+
+// -------------------------------------------------------------------------
+// Base domain exception
+// -------------------------------------------------------------------------
+
+export class ${capitalized}DomainException extends Error {
+    /** Machine-readable error code for programmatic handling */
+    readonly code: string;
+
+    constructor(message: string, code: string) {
+        super(message);
+        this.name = "${capitalized}DomainException";
+        this.code = code;
+
+        // Maintains proper prototype chain in TypeScript
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+
+// -------------------------------------------------------------------------
+// Specific domain exceptions
+// -------------------------------------------------------------------------
+
+/**
+ * Thrown when a ${featureName} cannot be found by its identifier.
+ * The controller should translate this to HTTP 404.
+ */
+export class ${capitalized}NotFoundException extends ${capitalized}DomainException {
+    constructor(id: string) {
+        super(
+            \`${capitalized} with id "\${id}" does not exist.\`,
+            "${featureName.toUpperCase()}_NOT_FOUND",
+        );
+        this.name = "${capitalized}NotFoundException";
+    }
+}
+
+/**
+ * Thrown when an operation violates a uniqueness constraint.
+ * The controller should translate this to HTTP 409.
+ */
+export class ${capitalized}AlreadyExistsException extends ${capitalized}DomainException {
+    constructor(field: string, value: string) {
+        super(
+            \`A ${featureName} with \${field} "\${value}" already exists.\`,
+            "${featureName.toUpperCase()}_ALREADY_EXISTS",
+        );
+        this.name = "${capitalized}AlreadyExistsException";
+    }
+}
+
+/**
+ * Thrown when the provided data violates a business invariant.
+ * The controller should translate this to HTTP 422.
+ */
+export class ${capitalized}InvalidDataException extends ${capitalized}DomainException {
+    constructor(reason: string) {
+        super(
+            \`Invalid ${featureName} data: \${reason}\`,
+            "${featureName.toUpperCase()}_INVALID_DATA",
+        );
+        this.name = "${capitalized}InvalidDataException";
+    }
+}
+
+// -------------------------------------------------------------------------
+// Exception guard helper
+// -------------------------------------------------------------------------
+
+/**
+ * Type guard to check if an unknown error is a ${capitalized}DomainException.
+ * Use this in your controller's catch block to map domain errors to HTTP responses.
+ *
+ * @example
+ * try {
+ *   await useCase.create(dto);
+ * } catch (error) {
+ *   if (is${capitalized}DomainException(error)) {
+ *     switch (error.code) {
+ *       case "${featureName.toUpperCase()}_NOT_FOUND":     return res.status(404).json(...);
+ *       case "${featureName.toUpperCase()}_ALREADY_EXISTS": return res.status(409).json(...);
+ *       case "${featureName.toUpperCase()}_INVALID_DATA":   return res.status(422).json(...);
+ *     }
+ *   }
+ *   // Unknown error \u2014 rethrow or return 500
+ *   throw error;
+ * }
+ */
+export const is${capitalized}DomainException = (error: unknown): error is ${capitalized}DomainException =>
+    error instanceof ${capitalized}DomainException;
+`;
+    };
+    capitalize10 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+  }
+});
+
+// src/templates/cleanComponents/service.template.ts
+var generateServiceTemplate, capitalize11;
+var init_service_template = __esm({
+  "src/templates/cleanComponents/service.template.ts"() {
+    "use strict";
+    init_cjs_shims();
+    generateServiceTemplate = (featureName) => {
+      const capitalized = capitalize11(featureName);
+      return `import { ${capitalized}ResponseDto } from "../../dtos/${featureName}.dto";
+
+/**
+ * I${capitalized}Service \u2014 Application Service Port
+ *
+ * Application services handle orchestration logic that sits ABOVE a single use case
+ * but BELOW the HTTP layer. They are the right place for:
+ *
+ *  - Cross-use-case workflows (e.g. "create + notify + log in one transaction")
+ *  - Business rules that span multiple aggregates
+ *  - Coordination with external systems (email, payment, 3rd-party APIs)
+ *    whose contracts are defined here as abstractions
+ *
+ * The infrastructure layer provides the concrete implementation.
+ * Use cases depend on this interface \u2014 never on the concrete class.
+ */
+export interface I${capitalized}Service {
+
+    /**
+     * Full creation workflow for a ${featureName}.
+     * May involve validation, persistence, event publishing, notifications, etc.
+     *
+     * @param data - Raw input (already validated by the controller)
+     * @returns The created ${featureName} as a response DTO
+     */
+    handleCreate(data: Record<string, unknown>): Promise<${capitalized}ResponseDto>;
+
+    /**
+     * Full update workflow for a ${featureName}.
+     *
+     * @param id  - Identifier of the ${featureName} to update
+     * @param data - Fields to update
+     * @returns The updated ${featureName}, or null if not found
+     */
+    handleUpdate(id: string, data: Record<string, unknown>): Promise<${capitalized}ResponseDto | null>;
+
+    /**
+     * Full deletion workflow for a ${featureName}.
+     * May involve cleanup tasks (remove related files, revoke tokens, etc.)
+     *
+     * @param id - Identifier of the ${featureName} to delete
+     * @returns true if deleted, false if not found
+     */
+    handleDelete(id: string): Promise<boolean>;
+
+    // TODO: Add feature-specific service methods below
+    // Example:
+    // sendWelcomeNotification(id: string): Promise<void>;
+    // exportToCsv(filters: Record<string, unknown>): Promise<Buffer>;
+}
+`;
+    };
+    capitalize11 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+  }
+});
+
+// src/templates/simpleComponent/model.template.ts
+var generateModelTemplate, capitalize12;
+var init_model_template = __esm({
+  "src/templates/simpleComponent/model.template.ts"() {
+    "use strict";
+    init_cjs_shims();
+    generateModelTemplate = (featureName) => {
+      const capitalized = capitalize12(featureName);
+      const modelName = `${capitalized}Model`;
+      return `/**
+ * ${modelName} \u2014 Data Model
+ * Plain data structure for the "${featureName}" feature.
+ */
+export class ${modelName} {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+
+    constructor(
+        id: string,
+        // TODO: Add your model properties here
+        createdAt?: Date,
+        updatedAt?: Date,
+    ) {
+        this.id = id;
+        this.createdAt = createdAt ?? new Date();
+        this.updatedAt = updatedAt ?? new Date();
+    }
+}
+`;
+    };
+    capitalize12 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+  }
+});
+
+// src/templates/simpleComponent/simpleRepository.template.ts
+var generateSimpleRepositoryTemplate, capitalize13;
+var init_simpleRepository_template = __esm({
+  "src/templates/simpleComponent/simpleRepository.template.ts"() {
+    "use strict";
+    init_cjs_shims();
+    generateSimpleRepositoryTemplate = (featureName) => {
+      const capitalized = capitalize13(featureName);
+      const repoName = `${capitalized}Repository`;
+      const modelName = `${capitalized}Model`;
+      return `import { ${modelName} } from "../models/${featureName}.model";
+
+export class ${repoName} {
+    private store: Map<string, ${modelName}> = new Map();
+
+    async findAll(): Promise<${modelName}[]> {
+        // TODO: Replace with your ORM query
+        return Array.from(this.store.values());
+    }
+
+    async findById(id: string): Promise<${modelName} | null> {
+        // TODO: Replace with your ORM query
+        return this.store.get(id) ?? null;
+    }
+
+    async create(model: ${modelName}): Promise<${modelName}> {
+        // TODO: Replace with your ORM save
+        this.store.set(model.id, model);
+        return model;
+    }
+
+    async update(model: ${modelName}): Promise<${modelName} | null> {
+        // TODO: Replace with your ORM update
+        if (!this.store.has(model.id)) return null;
+        this.store.set(model.id, model);
+        return model;
+    }
+
+    async delete(id: string): Promise<boolean> {
+        // TODO: Replace with your ORM delete
+        return this.store.delete(id);
+    }
+}
+`;
+    };
+    capitalize13 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+  }
+});
+
+// src/templates/simpleComponent/simpleService.template.ts
+var generateSimpleServiceTemplate, capitalize14;
+var init_simpleService_template = __esm({
+  "src/templates/simpleComponent/simpleService.template.ts"() {
+    "use strict";
+    init_cjs_shims();
+    generateSimpleServiceTemplate = (featureName) => {
+      const capitalized = capitalize14(featureName);
+      const serviceName = `${capitalized}Service`;
+      const repoName = `${capitalized}Repository`;
+      const modelName = `${capitalized}Model`;
+      return `import { ${repoName} } from "../repositories/${featureName}.repository";
+import { ${modelName} } from "../models/${featureName}.model";
+
+export class ${serviceName} {
+    private readonly repository: ${repoName};
+
+    constructor() {
+        this.repository = new ${repoName}();
+    }
+
+    async findAll(): Promise<${modelName}[]> {
+        return this.repository.findAll();
+    }
+
+    async findById(id: string): Promise<${modelName} | null> {
+        return this.repository.findById(id);
+    }
+
+    async create(data: Record<string, unknown>): Promise<${modelName}> {
+        const model = new ${modelName}(String(Date.now()));
+        // TODO: Map data fields onto model
+        return this.repository.create(model);
+    }
+
+    async update(id: string, data: Record<string, unknown>): Promise<${modelName} | null> {
+        const existing = await this.repository.findById(id);
+        if (!existing) return null;
+        // TODO: Apply data fields onto existing model
+        return this.repository.update(existing);
+    }
+
+    async delete(id: string): Promise<boolean> {
+        return this.repository.delete(id);
+    }
+}
+`;
+    };
+    capitalize14 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+  }
+});
+
+// src/templates/simpleComponent/simpleController.template.ts
+var generateSimpleControllerTemplate, generateMethod2, generateFindAllMethod2, generateFindByIdMethod2, generateCreateMethod2, generateUpdateMethod2, generateDeleteMethod2, capitalize15;
+var init_simpleController_template = __esm({
+  "src/templates/simpleComponent/simpleController.template.ts"() {
+    "use strict";
+    init_cjs_shims();
+    generateSimpleControllerTemplate = (controllerName, featureName, methods) => {
+      const capitalized = capitalize15(featureName);
+      const serviceName = `${capitalized}Service`;
+      const methodsCode = methods.map((method) => generateMethod2(method, capitalized, serviceName)).join("\n");
+      return `import { Request, Response } from "express";
+import { ResponseHandler, HttpStatusCode, IResponseHandlerSuccessData } from "opticore-http-response";
+import { ${serviceName} } from "../services/${featureName}.service";
+
+export class ${controllerName} {
+    private static buildService(): ${serviceName} {
+        return new ${serviceName}();
+    }
+
+${methodsCode}
+    private static handleError(error: unknown) {
+        const message = error instanceof Error ? error.message : "Internal server error";
+        return ResponseHandler.error(message, HttpStatusCode.INTERNAL_SERVER_ERROR);
+    }
+}
+`;
+    };
+    generateMethod2 = (method, capitalized, serviceName) => {
+      const lower = method.toLowerCase();
+      if (lower.includes("findall") || lower.includes("getall")) return generateFindAllMethod2(method, capitalized);
+      if (lower.includes("findbyid") || lower.includes("getbyid") || lower.includes("getone")) return generateFindByIdMethod2(method, capitalized);
+      if (lower.includes("create") || lower.includes("add")) return generateCreateMethod2(method, capitalized);
+      if (lower.includes("update") || lower.includes("edit")) return generateUpdateMethod2(method, capitalized);
+      if (lower.includes("delete") || lower.includes("remove")) return generateDeleteMethod2(method, capitalized);
+      return `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const service = ${capitalized}Controller.buildService();
+            // TODO: Implement ${method} logic
+            return ResponseHandler.success({}, "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+    };
+    generateFindAllMethod2 = (method, capitalized) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const service = ${capitalized}Controller.buildService();
+            const results = await service.findAll();
+            return ResponseHandler.success(results, "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+    generateFindByIdMethod2 = (method, capitalized) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const { id } = req.params;
+            const service = ${capitalized}Controller.buildService();
+            const result = await service.findById(id);
+            if (!result) {
+                return ResponseHandler.error(\`Not found: \${id}\`, HttpStatusCode.NOT_FOUND);
+            }
+            return ResponseHandler.success(result, "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+    generateCreateMethod2 = (method, capitalized) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const service = ${capitalized}Controller.buildService();
+            const result = await service.create(req.body);
+            return ResponseHandler.success(result, "created", HttpStatusCode.CREATED);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+    generateUpdateMethod2 = (method, capitalized) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const { id } = req.params;
+            const service = ${capitalized}Controller.buildService();
+            const result = await service.update(id, req.body);
+            if (!result) {
+                return ResponseHandler.error(\`Not found: \${id}\`, HttpStatusCode.NOT_FOUND);
+            }
+            return ResponseHandler.success(result, "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+    generateDeleteMethod2 = (method, capitalized) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const { id } = req.params;
+            const service = ${capitalized}Controller.buildService();
+            const deleted = await service.delete(id);
+            if (!deleted) {
+                return ResponseHandler.error(\`Not found: \${id}\`, HttpStatusCode.NOT_FOUND);
+            }
+            return ResponseHandler.success(null, "deleted", HttpStatusCode.NO_CONTENT);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+    capitalize15 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+  }
+});
+
+// src/templates/simpleComponent/simpleRouter.template.ts
+var resolveRoute2, generateSimpleRouterHandlerTemplate, generateSimpleRouterTemplate, capitalize16;
+var init_simpleRouter_template = __esm({
+  "src/templates/simpleComponent/simpleRouter.template.ts"() {
+    "use strict";
+    init_cjs_shims();
+    resolveRoute2 = (methodName, featureName) => {
+      const lower = methodName.toLowerCase();
+      if (lower.includes("findall") || lower.includes("getall")) return { httpMethod: "get", path: `/${featureName}` };
+      if (lower.includes("findbyid") || lower.includes("getbyid") || lower.includes("getone")) return { httpMethod: "get", path: `/${featureName}/:id` };
+      if (lower.includes("create") || lower.includes("add")) return { httpMethod: "post", path: `/${featureName}` };
+      if (lower.includes("update") || lower.includes("edit")) return { httpMethod: "put", path: `/${featureName}/:id` };
+      if (lower.includes("delete") || lower.includes("remove")) return { httpMethod: "delete", path: `/${featureName}/:id` };
+      return { httpMethod: "get", path: `/${featureName}/${lower}` };
+    };
+    generateSimpleRouterHandlerTemplate = (featureName, controllerMethods) => {
+      const capitalized = capitalize16(featureName);
+      const handlerName = `${capitalized}HandlerRouter`;
+      const controllerName = `${capitalized}Controller`;
+      const routesCode = (controllerMethods || []).map((method) => {
+        const { httpMethod, path: path7 } = resolveRoute2(method, featureName);
+        return `{
+    path: \`${path7}\`,
+    method: "${httpMethod}",
+    middlewares: [],
+    handler: async (ctx: ICustomContext) => await ${controllerName}.${method}(ctx.req, ctx.res)
+}`;
+      }).join(",\n");
+      return `import { OpticoreRouting, ICustomContext, IMultipleRouteDefinition } from "opticore-router";
+import { ${controllerName} } from "../controllers/${featureName}.controller";
+
+export const ${handlerName}: () => IMultipleRouteDefinition = () => {
+    return OpticoreRouting.routes(
+        ${controllerName},
+        [
+            ${routesCode.replace(/\n/g, "\n            ")}
+        ]
+    );
+};
+`;
+    };
+    generateSimpleRouterTemplate = (featureName) => {
+      const capitalized = capitalize16(featureName);
+      const handlerName = `${capitalized}HandlerRouter`;
+      const routerName = `${capitalized}Router`;
+      return `import { ${handlerName} } from "./${featureName}.router.handler";
+import { TFeatureRoutes } from "opticore-router";
+
+export const ${routerName}: TFeatureRoutes = {
+    routes: [
+        {
+            path: ${handlerName}().path,
+            handler: ${handlerName}().handler
+        }
+    ]
+};
+`;
+    };
+    capitalize16 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+  }
+});
+
+// src/utils/featureComponentGenerator.utils.ts
+var import_path2, import_ansi_colors6, import_fs2, import_opticore_logger2, FeatureComponentGeneratorUtils;
+var init_featureComponentGenerator_utils = __esm({
+  "src/utils/featureComponentGenerator.utils.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_path2 = __toESM(require("path"), 1);
+    import_ansi_colors6 = __toESM(require("ansi-colors"), 1);
+    import_fs2 = __toESM(require("fs"), 1);
+    init_prompt_utils();
+    init_fsModule_utils();
+    import_opticore_logger2 = require("opticore-logger");
+    init_controller_template();
+    init_entity_template();
+    init_repositoryInterface_template();
+    init_repositoryImpl_template();
+    init_useCase_template();
+    init_dto_template();
+    init_presenter_template();
+    init_router_template();
+    init_event_template();
+    init_exception_template();
+    init_service_template();
+    init_model_template();
+    init_simpleRepository_template();
+    init_simpleService_template();
+    init_simpleController_template();
+    init_simpleRouter_template();
+    FeatureComponentGeneratorUtils = class {
+      static logger = new import_opticore_logger2.LoggerCore();
+      static REGISTER_ROUTER_PATH = import_path2.default.join(process.cwd(), "src/app/router/register.router.ts");
+      static structure = "clean";
+      static setStructure(s) {
+        this.structure = s;
+      }
+      /**
+       * Creates the domain entity file.
+       * File: domain/entities/<featureName>.entity.ts
+       */
+      static async createEntity(featureName, entityDir) {
+        const entityName = `${this.capitalize(featureName)}Entity`;
+        const filePath = import_path2.default.join(entityDir, `${featureName}.entity.ts`);
+        UFsModule.createFile(filePath, generateEntityTemplate(entityName, featureName));
+        console.log(import_ansi_colors6.default.green(`\u2705 Entity created: ${filePath}`));
+      }
+      /**
+       * Creates the domain event file.
+       * File: domain/events/<featureName>.event.ts
+       */
+      static async createEvent(featureName, eventDir) {
+        const filePath = import_path2.default.join(eventDir, `${featureName}.event.ts`);
+        UFsModule.createFile(filePath, generateEventTemplate(featureName));
+        console.log(import_ansi_colors6.default.green(`\u2705 Event created: ${filePath}`));
+      }
+      /**
+       * Creates the domain exception file.
+       * File: domain/exceptions/<featureName>.exception.ts
+       */
+      static async createException(featureName, exceptionDir) {
+        const filePath = import_path2.default.join(exceptionDir, `${featureName}.exception.ts`);
+        UFsModule.createFile(filePath, generateExceptionTemplate(featureName));
+        console.log(import_ansi_colors6.default.green(`\u2705 Exception created: ${filePath}`));
+      }
+      /**
+       * Creates the repository port interface.
+       * File: application/ports/repositories/<featureName>.repository.interface.ts
+       */
+      static async createRepositoryInterface(featureName, interfaceDir) {
+        const interfaceName = `I${this.capitalize(featureName)}Repository`;
+        const filePath = import_path2.default.join(interfaceDir, `${featureName}.repository.interface.ts`);
+        UFsModule.createFile(filePath, generateRepositoryInterfaceTemplate(interfaceName, featureName));
+        console.log(import_ansi_colors6.default.green(`\u2705 Repository interface created: ${filePath}`));
+      }
+      /**
+       * Creates the presenter port interface.
+       * File: application/ports/presenters/<featureName>.presenter.interface.ts
+       */
+      static async createPresenterInterface(featureName, presenterInterfaceDir) {
+        const filePath = import_path2.default.join(presenterInterfaceDir, `${featureName}.presenter.interface.ts`);
+        UFsModule.createFile(filePath, generatePresenterInterfaceTemplate(featureName));
+        console.log(import_ansi_colors6.default.green(`\u2705 Presenter interface created: ${filePath}`));
+      }
+      /**
+       * Creates the application service port interface.
+       * File: application/ports/services/<featureName>.service.ts
+       */
+      static async createService(featureName, serviceDir) {
+        const filePath = import_path2.default.join(serviceDir, `${featureName}.service.ts`);
+        UFsModule.createFile(filePath, generateServiceTemplate(featureName));
+        console.log(import_ansi_colors6.default.green(`\u2705 Service interface created: ${filePath}`));
+      }
+      /**
+       * Creates the DTO file (input + output shapes + mapper).
+       * File: application/dtos/<featureName>.dto.ts
+       */
+      static async createDto(featureName, dtoDir) {
+        const filePath = import_path2.default.join(dtoDir, `${featureName}.dto.ts`);
+        UFsModule.createFile(filePath, generateDtoTemplate(featureName));
+        console.log(import_ansi_colors6.default.green(`\u2705 DTO created: ${filePath}`));
+      }
+      /**
+       * Creates the use case file.
+       * File: application/use-cases/<featureName>.usecase.ts
+       */
+      static async createUseCase(featureName, useCaseDir) {
+        const useCaseName = `${this.capitalize(featureName)}UseCase`;
+        const filePath = import_path2.default.join(useCaseDir, `${featureName}.usecase.ts`);
+        UFsModule.createFile(filePath, generateUseCaseTemplate(useCaseName, featureName));
+        console.log(import_ansi_colors6.default.green(`\u2705 UseCase created: ${filePath}`));
+      }
+      // =========================================================================
+      // INFRASTRUCTURE LAYER
+      // =========================================================================
+      /**
+       * Creates the concrete repository implementation.
+       * File: infrastructure/adapters/repositories/<featureName>.repository.ts
+       */
+      static async createRepositoryImpl(featureName, repositoryImplDir) {
+        const interfaceImportPath = `../../../application/ports/repositories/${featureName}.repository.interface`;
+        const filePath = import_path2.default.join(repositoryImplDir, `${featureName}.repository.ts`);
+        UFsModule.createFile(filePath, generateRepositoryImplTemplate(featureName, interfaceImportPath));
+        console.log(import_ansi_colors6.default.green(`\u2705 Repository implementation created: ${filePath}`));
+      }
+      /**
+       * Creates the concrete presenter implementation.
+       * File: infrastructure/adapters/presenters/<featureName>.presenter.ts
+       */
+      static async createPresenterImpl(featureName, presenterImplDir) {
+        const filePath = import_path2.default.join(presenterImplDir, `${featureName}.presenter.ts`);
+        UFsModule.createFile(filePath, generatePresenterImplTemplate(featureName));
+        console.log(import_ansi_colors6.default.green(`\u2705 Presenter implementation created: ${filePath}`));
+      }
+      /**
+       * Creates the HTTP controller.
+       * Prompts the user for method names, then generates the file.
+       * File: infrastructure/adapters/controllers/<featureName>.controller.ts
+       *
+       * @returns The controller class name and the list of chosen methods.
+       */
+      static async createController(featureName, controllerDir) {
+        const controllerName = `${this.capitalize(featureName)}Controller`;
+        const filePath = import_path2.default.join(controllerDir, `${featureName}.controller.ts`);
+        const wantsMethods = await UPrompt.confirm("Do you want to add methods to the controller?");
+        let methods = [];
+        let content;
+        if (wantsMethods) {
+          const methodsText = await UPrompt.text(
+            "Enter the method names (comma separated):",
+            "create, findAll, findById, update, delete",
+            (v) => v ? void 0 : "You must enter at least one method."
+          );
+          methods = methodsText.split(",").map((m) => m.trim()).filter(Boolean);
+          content = generateControllerTemplate(controllerName, featureName, methods);
+        } else {
+          content = `import { Request, Response } from "express";
+
+export class ${controllerName} {}
+`;
+        }
+        UFsModule.createFile(filePath, content);
+        console.log(import_ansi_colors6.default.green(`\u2705 Controller created: ${filePath}`));
+        return { controllerName, methods };
+      }
+      /**
+       * Creates the data model file (simple component).
+       * File: models/<featureName>.model.ts
+       */
+      static async createModel(featureName, modelDir) {
+        const filePath = import_path2.default.join(modelDir, `${featureName}.model.ts`);
+        UFsModule.createFile(filePath, generateModelTemplate(featureName));
+        console.log(import_ansi_colors6.default.green(`\u2705 Model created: ${filePath}`));
+      }
+      /**
+       * Creates the simple repository (no interface, uses the model directly).
+       * File: repositories/<featureName>.repository.ts
+       */
+      static async createSimpleRepository(featureName, repositoryDir) {
+        const filePath = import_path2.default.join(repositoryDir, `${featureName}.repository.ts`);
+        UFsModule.createFile(filePath, generateSimpleRepositoryTemplate(featureName));
+        console.log(import_ansi_colors6.default.green(`\u2705 Repository created: ${filePath}`));
+      }
+      /**
+       * Creates the simple concrete service (no interface, wires the repository).
+       * File: services/<featureName>.service.ts
+       */
+      static async createSimpleService(featureName, serviceDir) {
+        const filePath = import_path2.default.join(serviceDir, `${featureName}.service.ts`);
+        UFsModule.createFile(filePath, generateSimpleServiceTemplate(featureName));
+        console.log(import_ansi_colors6.default.green(`\u2705 Service created: ${filePath}`));
+      }
+      /**
+       * Creates the simple controller (delegates to service, no use-case/presenter).
+       * File: controllers/<featureName>.controller.ts
+       */
+      static async createSimpleController(featureName, controllerDir) {
+        const controllerName = `${this.capitalize(featureName)}Controller`;
+        const filePath = import_path2.default.join(controllerDir, `${featureName}.controller.ts`);
+        const wantsMethods = await UPrompt.confirm("Do you want to add methods to the controller?");
+        let methods = [];
+        let content;
+        if (wantsMethods) {
+          const methodsText = await UPrompt.text(
+            "Enter the method names (comma separated):",
+            "create, findAll, findById, update, delete",
+            (v) => v ? void 0 : "You must enter at least one method."
+          );
+          methods = methodsText.split(",").map((m) => m.trim()).filter(Boolean);
+          content = generateSimpleControllerTemplate(controllerName, featureName, methods);
+        } else {
+          content = `import { Request, Response } from "express";
+
+export class ${controllerName} {}
+`;
+        }
+        UFsModule.createFile(filePath, content);
+        console.log(import_ansi_colors6.default.green(`\u2705 Controller created: ${filePath}`));
+        return { controllerName, methods };
+      }
+      /**
+       * Creates the route handler (HTTP verb + path → controller method bindings).
+       * File: infrastructure/routes/<featureName>.router.handler.ts  (clean)
+       *       routes/<featureName>.router.handler.ts                  (simple)
+       */
+      static async createRouterHandler(featureName, routerHandlerDir, controllerMethods) {
+        const filePath = import_path2.default.join(routerHandlerDir, `${featureName}.router.handler.ts`);
+        const content = this.structure === "simple" ? generateSimpleRouterHandlerTemplate(featureName, controllerMethods) : generateRouterHandlerTemplate(featureName, controllerMethods);
+        UFsModule.createFile(filePath, content);
+        console.log(import_ansi_colors6.default.green(`\u2705 Router Handler created: ${filePath}`));
+      }
+      /**
+       * Creates the feature router and registers it in register.router.ts.
+       * File: infrastructure/routes/<featureName>.router.ts  (clean)
+       *       routes/<featureName>.router.ts                  (simple)
+       */
+      static async createRouter(featureName, routerDir) {
+        const filePath = import_path2.default.join(routerDir, `${featureName}.router.ts`);
+        const content = this.structure === "simple" ? generateSimpleRouterTemplate(featureName) : generateRouterTemplate(featureName);
+        UFsModule.createFile(filePath, content);
+        await this.updateRegisterRouter(featureName);
+        console.log(import_ansi_colors6.default.green(`\u2705 Router created: ${filePath}`));
+      }
+      static capitalize(str) {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+      }
+      /**
+       * Appends an import and registers the new router in register.router.ts.
+       */
+      static async updateRegisterRouter(featureName) {
+        const routerName = `${this.capitalize(featureName)}Router`;
+        const routerPath = this.structure === "simple" ? `../../features/${featureName}/routes/${featureName}.router` : `../../features/${featureName}/infrastructure/routes/${featureName}.router`;
+        const importStatement = `import { ${routerName} } from "${routerPath}"`;
+        try {
+          if (!import_fs2.default.existsSync(this.REGISTER_ROUTER_PATH)) {
+            console.log(
+              import_ansi_colors6.default.yellow(`\u26A0\uFE0F  register.router.ts not found at ${this.REGISTER_ROUTER_PATH}, skipping auto-registration.`)
+            );
+            return;
+          }
+          let content = import_fs2.default.readFileSync(this.REGISTER_ROUTER_PATH, "utf-8");
+          if (content.includes(`import { ${routerName} } from`)) {
+            console.log(import_ansi_colors6.default.cyan(`\u2139\uFE0F  ${routerName} is already registered.`));
+            return;
+          }
+          const lines = content.split("\n");
+          let lastImportIndex = -1;
+          for (let i = 0; i < lines.length; i++) {
+            if (lines[i].trim().startsWith("import ")) lastImportIndex = i;
+          }
+          if (lastImportIndex !== -1) {
+            lines.splice(lastImportIndex + 1, 0, importStatement);
+            content = lines.join("\n");
+          } else {
+            content = importStatement + "\n" + content;
+          }
+          const ARRAY_OPEN = "registered([";
+          const ARRAY_CLOSE = "]);";
+          const startIdx = content.indexOf(ARRAY_OPEN);
+          if (startIdx === -1) {
+            console.log(import_ansi_colors6.default.yellow(`\u26A0\uFE0F  Could not find 'registered([' in register.router.ts.`));
+            return;
+          }
+          const endIdx = content.indexOf(ARRAY_CLOSE, startIdx + ARRAY_OPEN.length);
+          if (endIdx === -1) {
+            console.log(import_ansi_colors6.default.yellow(`\u26A0\uFE0F  Could not find matching ']);' in register.router.ts.`));
+            return;
+          }
+          const arrayContent = content.substring(startIdx + ARRAY_OPEN.length, endIdx);
+          const existingRoutes = arrayContent.split("\n").map((l) => l.trim().replace(/,+$/, "")).filter(Boolean);
+          if (!existingRoutes.includes(routerName)) {
+            existingRoutes.push(routerName);
+          }
+          const indentedRoutes = existingRoutes.map((r) => `        ${r},`).join("\n");
+          const newContent = content.substring(0, startIdx + ARRAY_OPEN.length) + `
+${indentedRoutes}
+    ` + content.substring(endIdx);
+          import_fs2.default.writeFileSync(this.REGISTER_ROUTER_PATH, newContent, "utf-8");
+          console.log(import_ansi_colors6.default.green(`\u2705 register.router.ts updated with ${routerName}.`));
+        } catch (error) {
+          console.error(import_ansi_colors6.default.red(`\u274C Failed to update register.router.ts: ${error.message}`));
+        }
+      }
+    };
+  }
+});
+
+// src/templates/simpleComponent/simpleComponent.template.ts
+var import_path3, import_ansi_colors7, simpleComponentTemplate;
+var init_simpleComponent_template = __esm({
+  "src/templates/simpleComponent/simpleComponent.template.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_path3 = __toESM(require("path"), 1);
+    import_ansi_colors7 = __toESM(require("ansi-colors"), 1);
+    init_fsModule_utils();
+    init_featureComponentGenerator_utils();
+    simpleComponentTemplate = async (featureName) => {
+      FeatureComponentGeneratorUtils.setStructure("simple");
+      const basePath = import_path3.default.join("src", "features", featureName);
+      const dirs = [
+        import_path3.default.join(basePath, "routes"),
+        import_path3.default.join(basePath, "controllers"),
+        import_path3.default.join(basePath, "services"),
+        import_path3.default.join(basePath, "repositories"),
+        import_path3.default.join(basePath, "models")
+      ];
+      dirs.forEach((dir) => UFsModule.createDirectoryRecursively(dir));
+      const paths = {
+        modelsDir: import_path3.default.join(basePath, "models"),
+        repositoriesDir: import_path3.default.join(basePath, "repositories"),
+        servicesDir: import_path3.default.join(basePath, "services"),
+        controllersDir: import_path3.default.join(basePath, "controllers"),
+        routesDir: import_path3.default.join(basePath, "routes")
+      };
+      await FeatureComponentGeneratorUtils.createModel(featureName, paths.modelsDir);
+      await FeatureComponentGeneratorUtils.createSimpleRepository(featureName, paths.repositoriesDir);
+      await FeatureComponentGeneratorUtils.createSimpleService(featureName, paths.servicesDir);
+      const controller = await FeatureComponentGeneratorUtils.createSimpleController(
+        featureName,
+        paths.controllersDir
+      );
+      await FeatureComponentGeneratorUtils.createRouterHandler(featureName, paths.routesDir, controller.methods);
+      await FeatureComponentGeneratorUtils.createRouter(featureName, paths.routesDir);
+      console.log(
+        import_ansi_colors7.default.bgGreen(
+          import_ansi_colors7.default.white(`
+\u{1F389}  Feature "${featureName}" scaffolded with Simple Component!
+`)
+        )
+      );
+    };
+  }
+});
+
+// src/templates/fullCleanComponent/fullCleanComponent.template.ts
+var import_path4, import_ansi_colors8, fullCleanComponentTemplate;
+var init_fullCleanComponent_template = __esm({
+  "src/templates/fullCleanComponent/fullCleanComponent.template.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_path4 = __toESM(require("path"), 1);
+    import_ansi_colors8 = __toESM(require("ansi-colors"), 1);
+    init_fsModule_utils();
+    init_featureComponentGenerator_utils();
+    fullCleanComponentTemplate = async (featureName) => {
+      const basePath = import_path4.default.join("src", "features", featureName);
+      const dirs = [
+        // Domain
+        import_path4.default.join(basePath, "domain", "entities"),
+        import_path4.default.join(basePath, "domain", "events"),
+        import_path4.default.join(basePath, "domain", "exceptions"),
+        // Application
+        import_path4.default.join(basePath, "application", "use-cases"),
+        import_path4.default.join(basePath, "application", "dtos"),
+        import_path4.default.join(basePath, "application", "ports", "repositories"),
+        import_path4.default.join(basePath, "application", "ports", "presenters"),
+        import_path4.default.join(basePath, "application", "ports", "services"),
+        // Infrastructure
+        import_path4.default.join(basePath, "infrastructure", "adapters", "controllers"),
+        import_path4.default.join(basePath, "infrastructure", "adapters", "repositories"),
+        import_path4.default.join(basePath, "infrastructure", "adapters", "presenters"),
+        import_path4.default.join(basePath, "infrastructure", "routes")
+      ];
+      dirs.forEach((dir) => UFsModule.createDirectoryRecursively(dir));
+      const paths = {
+        // Domain
+        entityDir: import_path4.default.join(basePath, "domain", "entities"),
+        eventDir: import_path4.default.join(basePath, "domain", "events"),
+        exceptionDir: import_path4.default.join(basePath, "domain", "exceptions"),
+        // Application
+        repositoryInterfaceDir: import_path4.default.join(basePath, "application", "ports", "repositories"),
+        presenterInterfaceDir: import_path4.default.join(basePath, "application", "ports", "presenters"),
+        serviceDir: import_path4.default.join(basePath, "application", "ports", "services"),
+        dtoDir: import_path4.default.join(basePath, "application", "dtos"),
+        useCaseDir: import_path4.default.join(basePath, "application", "use-cases"),
+        // Infrastructure
+        repositoryImplDir: import_path4.default.join(basePath, "infrastructure", "adapters", "repositories"),
+        presenterImplDir: import_path4.default.join(basePath, "infrastructure", "adapters", "presenters"),
+        controllerDir: import_path4.default.join(basePath, "infrastructure", "adapters", "controllers"),
+        routerDir: import_path4.default.join(basePath, "infrastructure", "routes")
+      };
+      await FeatureComponentGeneratorUtils.createEntity(featureName, paths.entityDir);
+      await FeatureComponentGeneratorUtils.createEvent(featureName, paths.eventDir);
+      await FeatureComponentGeneratorUtils.createException(featureName, paths.exceptionDir);
+      await FeatureComponentGeneratorUtils.createRepositoryInterface(featureName, paths.repositoryInterfaceDir);
+      await FeatureComponentGeneratorUtils.createPresenterInterface(featureName, paths.presenterInterfaceDir);
+      await FeatureComponentGeneratorUtils.createService(featureName, paths.serviceDir);
+      await FeatureComponentGeneratorUtils.createDto(featureName, paths.dtoDir);
+      await FeatureComponentGeneratorUtils.createUseCase(featureName, paths.useCaseDir);
+      await FeatureComponentGeneratorUtils.createRepositoryImpl(featureName, paths.repositoryImplDir);
+      await FeatureComponentGeneratorUtils.createPresenterImpl(featureName, paths.presenterImplDir);
+      const controller = await FeatureComponentGeneratorUtils.createController(
+        featureName,
+        paths.controllerDir
+      );
+      await FeatureComponentGeneratorUtils.createRouterHandler(featureName, paths.routerDir, controller.methods);
+      await FeatureComponentGeneratorUtils.createRouter(featureName, paths.routerDir);
+      console.log(
+        import_ansi_colors8.default.bgGreen(
+          import_ansi_colors8.default.white(`
+\u{1F389}  Feature "${featureName}" scaffolded with Clean Architecture!
+`)
+        )
+      );
+    };
+  }
+});
+
+// src/templates/cleanComponentByStep/cleanComponentByStep.template.ts
+var import_path5, import_ansi_colors9, import_prompts3, cleanComponentByStepTemplate;
+var init_cleanComponentByStep_template = __esm({
+  "src/templates/cleanComponentByStep/cleanComponentByStep.template.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_path5 = __toESM(require("path"), 1);
+    import_ansi_colors9 = __toESM(require("ansi-colors"), 1);
+    import_prompts3 = require("@clack/prompts");
+    init_fsModule_utils();
+    init_prompt_utils();
+    cleanComponentByStepTemplate = async (featureName) => {
+      const base = import_path5.default.join("src", "features", featureName);
+      let created = 0;
+      const ask = async (label) => {
+        const answer = await UPrompt.confirm(label, false);
+        if ((0, import_prompts3.isCancel)(answer)) {
+          UFsModule.removeDir(base, true, true);
+          process.exit(0);
+        }
+        return answer;
+      };
+      const write = (dir, filename) => {
+        UFsModule.createDirectoryRecursively(dir);
+        const filePath = import_path5.default.join(dir, filename);
+        UFsModule.createFile(filePath, "");
+        console.log(import_ansi_colors9.default.green(`\u2705  Created: ${filePath}`));
+        created++;
+      };
+      console.log(import_ansi_colors9.default.bold(import_ansi_colors9.default.cyan("\n\u2500\u2500 Domain \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")));
+      if (await ask(`Entity          \u2192  ${featureName}.entity.ts`))
+        write(import_path5.default.join(base, "domain", "entities"), `${featureName}.entity.ts`);
+      if (await ask(`Event           \u2192  ${featureName}.event.ts`))
+        write(import_path5.default.join(base, "domain", "events"), `${featureName}.event.ts`);
+      if (await ask(`Exception       \u2192  ${featureName}.exception.ts`))
+        write(import_path5.default.join(base, "domain", "exceptions"), `${featureName}.exception.ts`);
+      console.log(import_ansi_colors9.default.bold(import_ansi_colors9.default.cyan("\n\u2500\u2500 Application \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")));
+      if (await ask(`Repo Interface  \u2192  ${featureName}.repository.interface.ts`))
+        write(import_path5.default.join(base, "application", "ports", "repositories"), `${featureName}.repository.interface.ts`);
+      if (await ask(`Presenter Port  \u2192  ${featureName}.presenter.interface.ts`))
+        write(import_path5.default.join(base, "application", "ports", "presenters"), `${featureName}.presenter.interface.ts`);
+      if (await ask(`Service Port    \u2192  ${featureName}.service.ts`))
+        write(import_path5.default.join(base, "application", "ports", "services"), `${featureName}.service.ts`);
+      if (await ask(`DTO             \u2192  ${featureName}.dto.ts`))
+        write(import_path5.default.join(base, "application", "dtos"), `${featureName}.dto.ts`);
+      if (await ask(`Use Case        \u2192  ${featureName}.usecase.ts`))
+        write(import_path5.default.join(base, "application", "use-cases"), `${featureName}.usecase.ts`);
+      console.log(import_ansi_colors9.default.bold(import_ansi_colors9.default.cyan("\n\u2500\u2500 Infrastructure \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")));
+      if (await ask(`Repo Impl       \u2192  ${featureName}.repository.ts`))
+        write(import_path5.default.join(base, "infrastructure", "adapters", "repositories"), `${featureName}.repository.ts`);
+      if (await ask(`Presenter Impl  \u2192  ${featureName}.presenter.ts`))
+        write(import_path5.default.join(base, "infrastructure", "adapters", "presenters"), `${featureName}.presenter.ts`);
+      if (await ask(`Controller      \u2192  ${featureName}.controller.ts`))
+        write(import_path5.default.join(base, "infrastructure", "adapters", "controllers"), `${featureName}.controller.ts`);
+      if (await ask(`Router Handler  \u2192  ${featureName}.router.handler.ts`))
+        write(import_path5.default.join(base, "infrastructure", "routes"), `${featureName}.router.handler.ts`);
+      if (await ask(`Router          \u2192  ${featureName}.router.ts`))
+        write(import_path5.default.join(base, "infrastructure", "routes"), `${featureName}.router.ts`);
+      if (created === 0) {
+        console.log(import_ansi_colors9.default.yellow(`
+\u26A0\uFE0F  No files were created for feature "${featureName}".`));
+      } else {
+        console.log(
+          import_ansi_colors9.default.bgGreen(import_ansi_colors9.default.white(`
+\u{1F389}  Feature "${featureName}" \u2014 ${created} file(s) created step by step.
+`))
+        );
+      }
+    };
+  }
+});
+
+// src/core/components/application/createController.application.ts
+var import_prompts4, createComponentApplication;
+var init_createController_application = __esm({
+  "src/core/components/application/createController.application.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_controllerType_service();
+    import_prompts4 = require("@clack/prompts");
+    init_base_service();
+    init_cleanType_constant();
+    init_simpleComponent_template();
+    init_fullCleanComponent_template();
+    init_cleanComponentByStep_template();
+    createComponentApplication = async (featureDirectory, featureName) => {
+      const askComponentType = await _controllerType(
+        "Choose a type of component :",
+        CCleanType.full_clean_component,
+        [
+          { label: "Simple component", value: [CCleanType.simple_component] },
+          { label: "CLEAN Architecture component by step", value: [CCleanType.clean_component_by_step] },
+          { label: "Full CLEAN Architecture component", value: [CCleanType.full_clean_component] }
+        ]
+      );
+      if ((0, import_prompts4.isCancel)(askComponentType) === true || askComponentType === void 0) {
+        BaseService._cancelOperation(featureDirectory);
+      } else {
+        switch (askComponentType) {
+          case CCleanType.simple_component:
+            await simpleComponentTemplate(featureName);
+            break;
+          case CCleanType.clean_component_by_step:
+            await cleanComponentByStepTemplate(featureName);
+            break;
+          case CCleanType.full_clean_component:
+            await fullCleanComponentTemplate(featureName);
+            break;
+        }
+      }
+    };
+  }
+});
+
+// src/core/core.ts
+var core_exports = {};
+var import_process3, import_node_fs2, import_path6, import_prompts5;
+var init_core = __esm({
+  "src/core/core.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_process3 = __toESM(require("process"), 1);
+    import_node_fs2 = __toESM(require("fs"), 1);
+    import_path6 = __toESM(require("path"), 1);
+    import_prompts5 = require("@clack/prompts");
+    init_welcomeMessage_utils();
+    init_choiceFeatureCleanModule();
+    init_customFeatureInfoMessage_constant();
+    init_customFeatureInfo_utils();
+    init_featureName_service();
+    init_base_service();
+    init_createController_application();
+    (async () => {
+      UWelcomeMessage();
+      const featureChoice = await choiceFeatureCleanModule();
+      featureChoice !== "opticore_clean_module" || featureChoice === void 0 ? customFeatureInfo() : UCustomFeatureInfo(featureChoice);
+      const featureName = await _featureName();
+      const directory = import_path6.default.join(import_process3.default.cwd(), "src", "features");
+      const featureDirectory = import_path6.default.join(directory, featureName.toString());
+      const featureCleanModule = BaseService._isSubdirectoryExists(featureName);
+      if (featureCleanModule) {
+        BaseService._featureFounded(featureName);
+      }
+      if ((0, import_prompts5.isCancel)(featureName)) {
+        BaseService._cancelOperation(featureDirectory);
+      } else {
+        try {
+          if (import_node_fs2.default.existsSync(directory)) {
+            await createComponentApplication(featureDirectory, featureName);
+          } else {
+            BaseService._checkFeatureDir();
+          }
+        } catch (err) {
+          console.error(err.message);
+          import_process3.default.exit();
+        }
+      }
+    })();
+  }
+});
+
+// src/index.ts
+init_cjs_shims();
+Promise.resolve().then(() => init_core());