opticore-feature-component 1.0.0

package/dist/core-ED52ORJA.js

@@ -0,0 +1,1950 @@
+// src/core/core.ts
+import process4 from "process";
+import fs4 from "fs";
+import path6 from "path";
+import { isCancel as isCancel4 } from "@clack/prompts";
+
+// src/utils/welcomeMessage.utils.ts
+import gradient from "gradient-string";
+function UWelcomeMessage() {
+  return console.log(gradient("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"
+  ));
+}
+
+// src/utils/choiceFeatureCleanModule.ts
+import colors2 from "ansi-colors";
+import { isCancel } from "@clack/prompts";
+
+// src/utils/prompt.utils.ts
+import { confirm, select, text } from "@clack/prompts";
+import colors from "ansi-colors";
+
+// src/utils/fsModule.utils.ts
+import fs from "fs";
+var UFsModule = class {
+  static createDirectoryRecursively(dirPath) {
+    try {
+      fs.mkdirSync(dirPath, { recursive: true });
+    } catch (e) {
+      console.error(e.message);
+    }
+  }
+  static createFile(filePath, fileContent) {
+    try {
+      fs.writeFileSync(filePath, fileContent);
+    } catch (e) {
+      console.error(e.message);
+    }
+  }
+  static removeDir(directory, recursive, force) {
+    try {
+      if (fs.existsSync(directory)) {
+        fs.rmSync(directory, { recursive, force });
+      }
+    } catch (e) {
+      console.error(`Error removing folder: ${e.message}`, e);
+      process.exit(0);
+    }
+  }
+};
+
+// src/utils/prompt.utils.ts
+import { LoggerCore } from "opticore-logger";
+import { HttpStatusCode } from "opticore-http-response";
+var UPrompt = class {
+  static logger = new LoggerCore();
+  static async text(message, placeholder, validate) {
+    return await text(
+      {
+        message,
+        placeholder,
+        validate
+      }
+    );
+  }
+  static async confirm(message, defaultValue = true) {
+    return await confirm({
+      message,
+      initialValue: defaultValue
+    });
+  }
+  static cancelOperation(controllerPath) {
+    console.log(`${colors.bgRed(`${colors.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: 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 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 (isCancel(featureSelected)) {
+    console.log(`${colors2.bgRed(`${colors2.white("Operation cancelled.")}`)}`);
+    process.exit(0);
+  } else {
+    return featureSelected;
+  }
+}
+
+// src/utils/constants/customFeatureInfoMessage.constant.ts
+import colors3 from "ansi-colors";
+import process2 from "process";
+function customFeatureInfo() {
+  console.log(`${colors3.bgCyan(`${colors3.white("\nYou will have to create and configure your created modules manually.")}`)}`);
+  process2.exit(0);
+}
+
+// src/utils/customFeatureInfo.utils.ts
+import colors4 from "ansi-colors";
+function UCustomFeatureInfo(choice) {
+  console.log(`You have chosen : ${choice === "opticore_clean_module" ? colors4.cyan("OptiCoreJs CLEAN Module") : colors4.cyan("Custom feature")} 
+`);
+  console.log(`Clean module contains the following files :`);
+  console.log(`${colors4.cyan("application")}`);
+  console.log(`     \u2570\u2500\u2500${colors4.bgBlackBright(`${colors4.white("{controller, service, validator}")}`)}`);
+  console.log(`${colors4.cyan("domain")}`);
+  console.log(`     \u2570\u2500\u2500${colors4.bgBlackBright(`${colors4.white("{constants, entities, enums, interfaces}")}`)}`);
+  console.log(`${colors4.cyan("infrastructures")}`);
+  console.log(`     \u2570\u2500\u2500${colors4.bgBlackBright(`${colors4.white("{api, middleware}")}`)}`);
+  console.log(`${colors4.cyan("persistence")}`);
+  console.log(`     \u2570\u2500\u2500${colors4.bgBlackBright(`${colors4.white("{cache, contrats, repositories, usecases}")}`)}`);
+  console.log(`${colors4.cyan("file")} : route of feature named ${colors4.cyan("featureName.router")} 
+`);
+  console.log(colors4.cyan("Now let's start create a feature !"));
+}
+
+// src/services/featureName.service.ts
+var _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
+import path from "path";
+import fs2 from "fs";
+import colors5 from "ansi-colors";
+import process3 from "process";
+var BaseService = class {
+  static _isSubdirectoryExists(subdirectory) {
+    const subdirectoryString = typeof subdirectory === "symbol" ? subdirectory.toString() : String(subdirectory);
+    const subdirectoryPath = path.join(process3.cwd(), "src", "features", subdirectoryString);
+    try {
+      const stats = fs2.statSync(subdirectoryPath);
+      return stats.isDirectory();
+    } catch (error) {
+      return false;
+    }
+  }
+  static _featureFounded(feature) {
+    console.log(`${colors5.bgCyan(`${colors5.white(`${colors5.bold(`feature ${feature} is already exists.`)}`)}`)}`);
+    process3.exit(0);
+  }
+  static _checkFeatureDir() {
+    console.error(`${colors5.bgRed(`${colors5.white("Check if directory src/features exists, and try again.")}`)}`);
+    process3.exit();
+  }
+  static _dirFounded(feature) {
+    console.error(`${colors5.bgRed(`${colors5.white(`The ${colors5.bgCyan(`${colors5.bold(`feature ${feature} is already exists.`)}`)}`)}`)}`);
+    process3.exit();
+  }
+  static _cancelOperation(controllerPath) {
+    console.log(`${colors5.bgRed(`${colors5.white("Operation cancelled.")}`)}`);
+    UFsModule.removeDir(controllerPath, true, true);
+    process3.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 ${colors5.bgCyan(colors5.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
+  );
+}
+
+// src/core/components/application/createController.application.ts
+import { isCancel as isCancel3 } from "@clack/prompts";
+
+// src/core/domains/constants/cleanType.constant.ts
+var CCleanType = {
+  "clean_component_by_step": "clean_component_by_step",
+  "full_clean_component": "full_clean_component",
+  "simple_component": "simple_component"
+};
+
+// src/templates/simpleComponent/simpleComponent.template.ts
+import path3 from "path";
+import colors7 from "ansi-colors";
+
+// src/utils/featureComponentGenerator.utils.ts
+import path2 from "path";
+import colors6 from "ansi-colors";
+import fs3 from "fs";
+import { LoggerCore as LoggerCore2 } from "opticore-logger";
+
+// src/templates/cleanComponents/controller.template.ts
+var 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}
+}
+`;
+};
+var 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);
+        }
+    }
+`;
+};
+var 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);
+        }
+    }
+`;
+var 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);
+        }
+    }
+`;
+var 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);
+        }
+    }
+`;
+var 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);
+        }
+    }
+`;
+var 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);
+        }
+    }
+`;
+var 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);
+    }
+`;
+var capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/cleanComponents/entity.template.ts
+var 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
+    }
+}
+`;
+};
+var capitalize2 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/cleanComponents/repositoryInterface.template.ts
+var 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>;
+}
+`;
+};
+var capitalize3 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/cleanComponents/repositoryImpl.template.ts
+var 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,
+        };
+    }
+}
+`;
+};
+var capitalize4 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/cleanComponents/useCase.template.ts
+var 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);
+    }
+}
+`;
+};
+var capitalize5 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/cleanComponents/dto.template.ts
+var 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));
+    }
+}
+`;
+};
+var capitalize6 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/cleanComponents/presenter.template.ts
+var 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;
+}
+`;
+};
+var 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.\`,
+        };
+    }
+}
+`;
+};
+var capitalize7 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/cleanComponents/router.template.ts
+var 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}` };
+};
+var 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            ")}
+        ]
+    );
+};
+`;
+};
+var 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
+        }
+    ]
+};
+`;
+};
+var capitalize8 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/cleanComponents/event.template.ts
+var 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;
+    }
+}
+`;
+};
+var capitalize9 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/cleanComponents/exception.template.ts
+var 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;
+`;
+};
+var capitalize10 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/cleanComponents/service.template.ts
+var 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>;
+}
+`;
+};
+var capitalize11 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/simpleComponent/model.template.ts
+var 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();
+    }
+}
+`;
+};
+var capitalize12 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/simpleComponent/simpleRepository.template.ts
+var 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);
+    }
+}
+`;
+};
+var capitalize13 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/simpleComponent/simpleService.template.ts
+var 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);
+    }
+}
+`;
+};
+var capitalize14 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/simpleComponent/simpleController.template.ts
+var 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);
+    }
+}
+`;
+};
+var 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);
+        }
+    }
+`;
+};
+var 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);
+        }
+    }
+`;
+var 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);
+        }
+    }
+`;
+var 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);
+        }
+    }
+`;
+var 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);
+        }
+    }
+`;
+var 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);
+        }
+    }
+`;
+var capitalize15 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/simpleComponent/simpleRouter.template.ts
+var 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}` };
+};
+var 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            ")}
+        ]
+    );
+};
+`;
+};
+var 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
+        }
+    ]
+};
+`;
+};
+var capitalize16 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/utils/featureComponentGenerator.utils.ts
+var FeatureComponentGeneratorUtils = class {
+  static logger = new LoggerCore2();
+  static REGISTER_ROUTER_PATH = path2.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 = path2.join(entityDir, `${featureName}.entity.ts`);
+    UFsModule.createFile(filePath, generateEntityTemplate(entityName, featureName));
+    console.log(colors6.green(`\u2705 Entity created: ${filePath}`));
+  }
+  /**
+   * Creates the domain event file.
+   * File: domain/events/<featureName>.event.ts
+   */
+  static async createEvent(featureName, eventDir) {
+    const filePath = path2.join(eventDir, `${featureName}.event.ts`);
+    UFsModule.createFile(filePath, generateEventTemplate(featureName));
+    console.log(colors6.green(`\u2705 Event created: ${filePath}`));
+  }
+  /**
+   * Creates the domain exception file.
+   * File: domain/exceptions/<featureName>.exception.ts
+   */
+  static async createException(featureName, exceptionDir) {
+    const filePath = path2.join(exceptionDir, `${featureName}.exception.ts`);
+    UFsModule.createFile(filePath, generateExceptionTemplate(featureName));
+    console.log(colors6.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 = path2.join(interfaceDir, `${featureName}.repository.interface.ts`);
+    UFsModule.createFile(filePath, generateRepositoryInterfaceTemplate(interfaceName, featureName));
+    console.log(colors6.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 = path2.join(presenterInterfaceDir, `${featureName}.presenter.interface.ts`);
+    UFsModule.createFile(filePath, generatePresenterInterfaceTemplate(featureName));
+    console.log(colors6.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 = path2.join(serviceDir, `${featureName}.service.ts`);
+    UFsModule.createFile(filePath, generateServiceTemplate(featureName));
+    console.log(colors6.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 = path2.join(dtoDir, `${featureName}.dto.ts`);
+    UFsModule.createFile(filePath, generateDtoTemplate(featureName));
+    console.log(colors6.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 = path2.join(useCaseDir, `${featureName}.usecase.ts`);
+    UFsModule.createFile(filePath, generateUseCaseTemplate(useCaseName, featureName));
+    console.log(colors6.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 = path2.join(repositoryImplDir, `${featureName}.repository.ts`);
+    UFsModule.createFile(filePath, generateRepositoryImplTemplate(featureName, interfaceImportPath));
+    console.log(colors6.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 = path2.join(presenterImplDir, `${featureName}.presenter.ts`);
+    UFsModule.createFile(filePath, generatePresenterImplTemplate(featureName));
+    console.log(colors6.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 = path2.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(colors6.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 = path2.join(modelDir, `${featureName}.model.ts`);
+    UFsModule.createFile(filePath, generateModelTemplate(featureName));
+    console.log(colors6.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 = path2.join(repositoryDir, `${featureName}.repository.ts`);
+    UFsModule.createFile(filePath, generateSimpleRepositoryTemplate(featureName));
+    console.log(colors6.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 = path2.join(serviceDir, `${featureName}.service.ts`);
+    UFsModule.createFile(filePath, generateSimpleServiceTemplate(featureName));
+    console.log(colors6.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 = path2.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(colors6.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 = path2.join(routerHandlerDir, `${featureName}.router.handler.ts`);
+    const content = this.structure === "simple" ? generateSimpleRouterHandlerTemplate(featureName, controllerMethods) : generateRouterHandlerTemplate(featureName, controllerMethods);
+    UFsModule.createFile(filePath, content);
+    console.log(colors6.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 = path2.join(routerDir, `${featureName}.router.ts`);
+    const content = this.structure === "simple" ? generateSimpleRouterTemplate(featureName) : generateRouterTemplate(featureName);
+    UFsModule.createFile(filePath, content);
+    await this.updateRegisterRouter(featureName);
+    console.log(colors6.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 (!fs3.existsSync(this.REGISTER_ROUTER_PATH)) {
+        console.log(
+          colors6.yellow(`\u26A0\uFE0F  register.router.ts not found at ${this.REGISTER_ROUTER_PATH}, skipping auto-registration.`)
+        );
+        return;
+      }
+      let content = fs3.readFileSync(this.REGISTER_ROUTER_PATH, "utf-8");
+      if (content.includes(`import { ${routerName} } from`)) {
+        console.log(colors6.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(colors6.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(colors6.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);
+      fs3.writeFileSync(this.REGISTER_ROUTER_PATH, newContent, "utf-8");
+      console.log(colors6.green(`\u2705 register.router.ts updated with ${routerName}.`));
+    } catch (error) {
+      console.error(colors6.red(`\u274C Failed to update register.router.ts: ${error.message}`));
+    }
+  }
+};
+
+// src/templates/simpleComponent/simpleComponent.template.ts
+var simpleComponentTemplate = async (featureName) => {
+  FeatureComponentGeneratorUtils.setStructure("simple");
+  const basePath = path3.join("src", "features", featureName);
+  const dirs = [
+    path3.join(basePath, "routes"),
+    path3.join(basePath, "controllers"),
+    path3.join(basePath, "services"),
+    path3.join(basePath, "repositories"),
+    path3.join(basePath, "models")
+  ];
+  dirs.forEach((dir) => UFsModule.createDirectoryRecursively(dir));
+  const paths = {
+    modelsDir: path3.join(basePath, "models"),
+    repositoriesDir: path3.join(basePath, "repositories"),
+    servicesDir: path3.join(basePath, "services"),
+    controllersDir: path3.join(basePath, "controllers"),
+    routesDir: path3.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(
+    colors7.bgGreen(
+      colors7.white(`
+\u{1F389}  Feature "${featureName}" scaffolded with Simple Component!
+`)
+    )
+  );
+};
+
+// src/templates/fullCleanComponent/fullCleanComponent.template.ts
+import path4 from "path";
+import colors8 from "ansi-colors";
+var fullCleanComponentTemplate = async (featureName) => {
+  const basePath = path4.join("src", "features", featureName);
+  const dirs = [
+    // Domain
+    path4.join(basePath, "domain", "entities"),
+    path4.join(basePath, "domain", "events"),
+    path4.join(basePath, "domain", "exceptions"),
+    // Application
+    path4.join(basePath, "application", "use-cases"),
+    path4.join(basePath, "application", "dtos"),
+    path4.join(basePath, "application", "ports", "repositories"),
+    path4.join(basePath, "application", "ports", "presenters"),
+    path4.join(basePath, "application", "ports", "services"),
+    // Infrastructure
+    path4.join(basePath, "infrastructure", "adapters", "controllers"),
+    path4.join(basePath, "infrastructure", "adapters", "repositories"),
+    path4.join(basePath, "infrastructure", "adapters", "presenters"),
+    path4.join(basePath, "infrastructure", "routes")
+  ];
+  dirs.forEach((dir) => UFsModule.createDirectoryRecursively(dir));
+  const paths = {
+    // Domain
+    entityDir: path4.join(basePath, "domain", "entities"),
+    eventDir: path4.join(basePath, "domain", "events"),
+    exceptionDir: path4.join(basePath, "domain", "exceptions"),
+    // Application
+    repositoryInterfaceDir: path4.join(basePath, "application", "ports", "repositories"),
+    presenterInterfaceDir: path4.join(basePath, "application", "ports", "presenters"),
+    serviceDir: path4.join(basePath, "application", "ports", "services"),
+    dtoDir: path4.join(basePath, "application", "dtos"),
+    useCaseDir: path4.join(basePath, "application", "use-cases"),
+    // Infrastructure
+    repositoryImplDir: path4.join(basePath, "infrastructure", "adapters", "repositories"),
+    presenterImplDir: path4.join(basePath, "infrastructure", "adapters", "presenters"),
+    controllerDir: path4.join(basePath, "infrastructure", "adapters", "controllers"),
+    routerDir: path4.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(
+    colors8.bgGreen(
+      colors8.white(`
+\u{1F389}  Feature "${featureName}" scaffolded with Clean Architecture!
+`)
+    )
+  );
+};
+
+// src/templates/cleanComponentByStep/cleanComponentByStep.template.ts
+import path5 from "path";
+import colors9 from "ansi-colors";
+import { isCancel as isCancel2 } from "@clack/prompts";
+var cleanComponentByStepTemplate = async (featureName) => {
+  const base = path5.join("src", "features", featureName);
+  let created = 0;
+  const ask = async (label) => {
+    const answer = await UPrompt.confirm(label, false);
+    if (isCancel2(answer)) {
+      UFsModule.removeDir(base, true, true);
+      process.exit(0);
+    }
+    return answer;
+  };
+  const write = (dir, filename) => {
+    UFsModule.createDirectoryRecursively(dir);
+    const filePath = path5.join(dir, filename);
+    UFsModule.createFile(filePath, "");
+    console.log(colors9.green(`\u2705  Created: ${filePath}`));
+    created++;
+  };
+  console.log(colors9.bold(colors9.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(path5.join(base, "domain", "entities"), `${featureName}.entity.ts`);
+  if (await ask(`Event           \u2192  ${featureName}.event.ts`))
+    write(path5.join(base, "domain", "events"), `${featureName}.event.ts`);
+  if (await ask(`Exception       \u2192  ${featureName}.exception.ts`))
+    write(path5.join(base, "domain", "exceptions"), `${featureName}.exception.ts`);
+  console.log(colors9.bold(colors9.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(path5.join(base, "application", "ports", "repositories"), `${featureName}.repository.interface.ts`);
+  if (await ask(`Presenter Port  \u2192  ${featureName}.presenter.interface.ts`))
+    write(path5.join(base, "application", "ports", "presenters"), `${featureName}.presenter.interface.ts`);
+  if (await ask(`Service Port    \u2192  ${featureName}.service.ts`))
+    write(path5.join(base, "application", "ports", "services"), `${featureName}.service.ts`);
+  if (await ask(`DTO             \u2192  ${featureName}.dto.ts`))
+    write(path5.join(base, "application", "dtos"), `${featureName}.dto.ts`);
+  if (await ask(`Use Case        \u2192  ${featureName}.usecase.ts`))
+    write(path5.join(base, "application", "use-cases"), `${featureName}.usecase.ts`);
+  console.log(colors9.bold(colors9.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(path5.join(base, "infrastructure", "adapters", "repositories"), `${featureName}.repository.ts`);
+  if (await ask(`Presenter Impl  \u2192  ${featureName}.presenter.ts`))
+    write(path5.join(base, "infrastructure", "adapters", "presenters"), `${featureName}.presenter.ts`);
+  if (await ask(`Controller      \u2192  ${featureName}.controller.ts`))
+    write(path5.join(base, "infrastructure", "adapters", "controllers"), `${featureName}.controller.ts`);
+  if (await ask(`Router Handler  \u2192  ${featureName}.router.handler.ts`))
+    write(path5.join(base, "infrastructure", "routes"), `${featureName}.router.handler.ts`);
+  if (await ask(`Router          \u2192  ${featureName}.router.ts`))
+    write(path5.join(base, "infrastructure", "routes"), `${featureName}.router.ts`);
+  if (created === 0) {
+    console.log(colors9.yellow(`
+\u26A0\uFE0F  No files were created for feature "${featureName}".`));
+  } else {
+    console.log(
+      colors9.bgGreen(colors9.white(`
+\u{1F389}  Feature "${featureName}" \u2014 ${created} file(s) created step by step.
+`))
+    );
+  }
+};
+
+// src/core/components/application/createController.application.ts
+var 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 (isCancel3(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
+(async () => {
+  UWelcomeMessage();
+  const featureChoice = await choiceFeatureCleanModule();
+  featureChoice !== "opticore_clean_module" || featureChoice === void 0 ? customFeatureInfo() : UCustomFeatureInfo(featureChoice);
+  const featureName = await _featureName();
+  const directory = path6.join(process4.cwd(), "src", "features");
+  const featureDirectory = path6.join(directory, featureName.toString());
+  const featureCleanModule = BaseService._isSubdirectoryExists(featureName);
+  if (featureCleanModule) {
+    BaseService._featureFounded(featureName);
+  }
+  if (isCancel4(featureName)) {
+    BaseService._cancelOperation(featureDirectory);
+  } else {
+    try {
+      if (fs4.existsSync(directory)) {
+        await createComponentApplication(featureDirectory, featureName);
+      } else {
+        BaseService._checkFeatureDir();
+      }
+    } catch (err) {
+      console.error(err.message);
+      process4.exit();
+    }
+  }
+})();