opticore-feature-component 1.0.5 → 1.0.7

package/dist/index.cjs

@@ -176,7 +176,9 @@ async function choiceFeatureCleanModule() {
     ["opticore_principle"],
     [
       { label: "OptiCoreJs CLEAN Module", value: ["opticore_clean_module"], hint: "recommended" },
-      { label: "Custom feature", value: ["custom_feature"] }
+      { label: "MVC Architecture", value: ["mvc_architecture"] },
+      { label: "Layered Architecture", value: ["layered_architecture"] },
+      { label: "Build your own architecture", value: ["custom_feature"] }
     ]
   );
   if ((0, import_prompts2.isCancel)(featureSelected)) {
@@ -1015,19 +1017,19 @@ var init_router_template = __esm({
       const handlerName = `${capitalized}HandlerRouter`;
       const controllerName = `${capitalized}Controller`;
       const routesCode = (controllerMethods || []).map((method) => {
-        const { httpMethod, path: path8 } = resolveRoute(method, featureName);
+        const { httpMethod, path: path10 } = resolveRoute(method, featureName);
         return `{
-    path: \`${path8}\`,
+    path: \`${path10}\`,
     method: "${httpMethod}",
     middlewares: [],
     handler: async (ctx: ICustomContext) => await ${controllerName}.${method}(ctx.req, ctx.res)
 }`;
       }).join(",\n");
-      return `import { OpticoreRouting, ICustomContext, IMultipleRouteDefinition } from "opticore-router";
+      return `import { OpticoreRoutingFactory, ICustomContext, IMultipleRouteDefinition } from "opticore-router";
 import { ${controllerName} } from "../adapters/controllers/${featureName}.controller";
 
 export const ${handlerName}: () => IMultipleRouteDefinition = () => {
-    return OpticoreRouting.routes(
+    return OpticoreRoutingFactory.routes(
         ${controllerName},
         [
             ${routesCode.replace(/\n/g, "\n            ")}
@@ -1591,19 +1593,19 @@ var init_simpleRouter_template = __esm({
       const handlerName = `${capitalized}HandlerRouter`;
       const controllerName = `${capitalized}Controller`;
       const routesCode = (controllerMethods || []).map((method) => {
-        const { httpMethod, path: path8 } = resolveRoute2(method, featureName);
+        const { httpMethod, path: path10 } = resolveRoute2(method, featureName);
         return `{
-    path: \`${path8}\`,
+    path: \`${path10}\`,
     method: "${httpMethod}",
     middlewares: [],
     handler: async (ctx: ICustomContext) => await ${controllerName}.${method}(ctx.req, ctx.res)
 }`;
       }).join(",\n");
-      return `import { OpticoreRouting, ICustomContext, IMultipleRouteDefinition } from "opticore-router";
+      return `import { OpticoreRoutingFactory, ICustomContext, IMultipleRouteDefinition } from "opticore-router";
 import { ${controllerName} } from "../controllers/${featureName}.controller";
 
 export const ${handlerName}: () => IMultipleRouteDefinition = () => {
-    return OpticoreRouting.routes(
+    return OpticoreRoutingFactory.routes(
         ${controllerName},
         [
             ${routesCode.replace(/\n/g, "\n            ")}
@@ -1870,7 +1872,7 @@ export class ${controllerName} {}
        */
       static async updateRegisterRouter(featureName) {
         const routerName = `${this.capitalize(featureName)}Router`;
-        const routerPath = this.structure === "simple" ? `../../features/${featureName}/routes/${featureName}.router` : this.structure === "custom" ? `../../features/${featureName}/${featureName}.router` : `../../features/${featureName}/infrastructure/routes/${featureName}.router`;
+        const routerPath = this.structure === "simple" || this.structure === "mvc" || this.structure === "layered" ? `../../features/${featureName}/routes/${featureName}.router` : this.structure === "custom" ? `../../features/${featureName}/${featureName}.router` : `../../features/${featureName}/infrastructure/routes/${featureName}.router`;
         const importStatement = `import { ${routerName} } from "${routerPath}"`;
         try {
           if (!import_fs2.default.existsSync(this.REGISTER_ROUTER_PATH)) {
@@ -2418,19 +2420,19 @@ export const ${moduleName.toUpperCase()}_PREFIX = "/${moduleName}";
       const handlerName = `${cap}HandlerRouter`;
       const controllerName = `${cap}Controller`;
       const routesCode = (controllerMethods || []).map((method) => {
-        const { httpMethod, path: path8 } = CResolveRoute(method, moduleName);
+        const { httpMethod, path: path10 } = CResolveRoute(method, moduleName);
         return `{
-    path: \`${path8}\`,
+    path: \`${path10}\`,
     method: "${httpMethod}",
     middlewares: [],
     handler: async (ctx: ICustomContext) => await ${controllerName}.${method}(ctx.req, ctx.res)
 }`;
       }).join(",\n");
-      return `import { OpticoreRouting, ICustomContext, IMultipleRouteDefinition } from "opticore-router";
+      return `import { OpticoreRoutingFactory, ICustomContext, IMultipleRouteDefinition } from "opticore-router";
 import { ${controllerName} } from "../../app/${moduleName}.controller";
 
 export const ${handlerName}: () => IMultipleRouteDefinition = () => {
-    return OpticoreRouting.routes(
+    return OpticoreRoutingFactory.routes(
         ${controllerName},
         [
             ${routesCode ? routesCode.replace(/\n/g, "\n            ") : ""}
@@ -2584,17 +2586,711 @@ ${import_ansi_colors9.default.bgGreen(import_ansi_colors9.default.white(`
   }
 });
 
+// src/templates/mvcModule/mvcModule.template.ts
+var capitalize19, generateMvcModelTemplate, generateMvcViewTemplate, generateMvcControllerTemplate, generateMethod4, generateFindAllMethod3, generateFindByIdMethod3, generateCreateMethod3, generateUpdateMethod3, generateDeleteMethod3, generateMvcRouterHandlerTemplate, generateMvcRouterTemplate, resolveRoute3;
+var init_mvcModule_template = __esm({
+  "src/templates/mvcModule/mvcModule.template.ts"() {
+    "use strict";
+    init_cjs_shims();
+    capitalize19 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+    generateMvcModelTemplate = (featureName) => {
+      const capitalized = capitalize19(featureName);
+      const modelName = `${capitalized}Model`;
+      return `/**
+ * ${modelName} \u2014 Model
+ * Owns both the data shape and the data-access logic for "${featureName}".
+ */
+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();
+    }
+
+    private static store: Map<string, ${modelName}> = new Map();
+
+    static async findAll(): Promise<${modelName}[]> {
+        // TODO: Replace with your ORM query
+        return Array.from(this.store.values());
+    }
+
+    static async findById(id: string): Promise<${modelName} | null> {
+        // TODO: Replace with your ORM query
+        return this.store.get(id) ?? null;
+    }
+
+    static async create(data: Record<string, unknown>): Promise<${modelName}> {
+        const model = new ${modelName}(String(Date.now()));
+        // TODO: Map data fields onto model
+        this.store.set(model.id, model);
+        return model;
+    }
+
+    static async update(id: string, data: Record<string, unknown>): Promise<${modelName} | null> {
+        const existing = this.store.get(id);
+        if (!existing) return null;
+        // TODO: Apply data fields onto existing model
+        existing.updatedAt = new Date();
+        this.store.set(id, existing);
+        return existing;
+    }
+
+    static async delete(id: string): Promise<boolean> {
+        // TODO: Replace with your ORM delete
+        return this.store.delete(id);
+    }
+}
+`;
+    };
+    generateMvcViewTemplate = (featureName) => {
+      const capitalized = capitalize19(featureName);
+      const modelName = `${capitalized}Model`;
+      const viewName = `${capitalized}View`;
+      return `import { ${modelName} } from "../models/${featureName}.model";
+
+/**
+ * ${viewName} \u2014 View
+ * Shapes "${featureName}" data before it is sent back as JSON.
+ */
+export class ${viewName} {
+    static toJSON(model: ${modelName}): Record<string, unknown> {
+        return {
+            id: model.id,
+            createdAt: model.createdAt,
+            updatedAt: model.updatedAt,
+            // TODO: expose the fields API consumers should see (and only those)
+        };
+    }
+
+    static toJSONList(models: ${modelName}[]): Record<string, unknown>[] {
+        return models.map((model: ${modelName}): Record<string, unknown> => this.toJSON(model));
+    }
+}
+`;
+    };
+    generateMvcControllerTemplate = (controllerName, featureName, methods) => {
+      const capitalized = capitalize19(featureName);
+      const modelName = `${capitalized}Model`;
+      const viewName = `${capitalized}View`;
+      const methodsCode = methods.map((method) => generateMethod4(method, capitalized, modelName, viewName)).join("\n");
+      return `import { Request, Response } from "opticore-express";
+import { ResponseHandler, HttpStatusCode, IResponseHandlerSuccessData } from "opticore-http-response";
+import { ${modelName} } from "../models/${featureName}.model";
+import { ${viewName} } from "../views/${featureName}.view";
+
+export class ${controllerName} {
+${methodsCode}
+    private static handleError(error: unknown) {
+        const message = error instanceof Error ? error.message : "Internal server error";
+        return ResponseHandler.error(message, HttpStatusCode.INTERNAL_SERVER_ERROR);
+    }
+}
+`;
+    };
+    generateMethod4 = (method, capitalized, modelName, viewName) => {
+      const lower = method.toLowerCase();
+      if (lower.includes("findall") || lower.includes("getall")) return generateFindAllMethod3(method, capitalized, modelName, viewName);
+      if (lower.includes("findbyid") || lower.includes("getbyid") || lower.includes("getone")) return generateFindByIdMethod3(method, capitalized, modelName, viewName);
+      if (lower.includes("create") || lower.includes("add")) return generateCreateMethod3(method, capitalized, modelName, viewName);
+      if (lower.includes("update") || lower.includes("edit")) return generateUpdateMethod3(method, capitalized, modelName, viewName);
+      if (lower.includes("delete") || lower.includes("remove")) return generateDeleteMethod3(method, capitalized, modelName);
+      return `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            // TODO: Implement ${method} logic
+            return ResponseHandler.success({}, "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+    };
+    generateFindAllMethod3 = (method, capitalized, modelName, viewName) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const models = await ${modelName}.findAll();
+            return ResponseHandler.success(${viewName}.toJSONList(models), "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+    generateFindByIdMethod3 = (method, capitalized, modelName, viewName) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const { id } = req.params;
+            const model = await ${modelName}.findById(id);
+            if (!model) {
+                return ResponseHandler.error(\`Not found: \${id}\`, HttpStatusCode.NOT_FOUND);
+            }
+            return ResponseHandler.success(${viewName}.toJSON(model), "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+    generateCreateMethod3 = (method, capitalized, modelName, viewName) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const model = await ${modelName}.create(req.body);
+            return ResponseHandler.success(${viewName}.toJSON(model), "created", HttpStatusCode.CREATED);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+    generateUpdateMethod3 = (method, capitalized, modelName, viewName) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const { id } = req.params;
+            const model = await ${modelName}.update(id, req.body);
+            if (!model) {
+                return ResponseHandler.error(\`Not found: \${id}\`, HttpStatusCode.NOT_FOUND);
+            }
+            return ResponseHandler.success(${viewName}.toJSON(model), "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+    generateDeleteMethod3 = (method, capitalized, modelName) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const { id } = req.params;
+            const deleted = await ${modelName}.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);
+        }
+    }
+`;
+    generateMvcRouterHandlerTemplate = (featureName, controllerMethods) => {
+      const capitalized = capitalize19(featureName);
+      const handlerName = `${capitalized}HandlerRouter`;
+      const controllerName = `${capitalized}Controller`;
+      const routesCode = (controllerMethods || []).map((method) => {
+        const { httpMethod, path: path10 } = resolveRoute3(method, featureName);
+        return `{
+    path: \`${path10}\`,
+    method: "${httpMethod}",
+    middlewares: [],
+    handler: async (ctx: ICustomContext) => await ${controllerName}.${method}(ctx.req, ctx.res)
+}`;
+      }).join(",\n");
+      return `import { OpticoreRoutingFactory, ICustomContext, IMultipleRouteDefinition } from "opticore-router";
+import { ${controllerName} } from "../controllers/${featureName}.controller";
+
+export const ${handlerName}: () => IMultipleRouteDefinition = () => {
+    return OpticoreRoutingFactory.routes(
+        ${controllerName},
+        [
+            ${routesCode.replace(/\n/g, "\n            ")}
+        ]
+    );
+};
+`;
+    };
+    generateMvcRouterTemplate = (featureName) => {
+      const capitalized = capitalize19(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
+        }
+    ]
+};
+`;
+    };
+    resolveRoute3 = (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}` };
+    };
+  }
+});
+
+// src/templates/mvcModule/mvcModuleScaffold.template.ts
+var import_path7, import_ansi_colors10, import_prompts6, capitalize20, mvcModuleTemplate;
+var init_mvcModuleScaffold_template = __esm({
+  "src/templates/mvcModule/mvcModuleScaffold.template.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_path7 = __toESM(require("path"), 1);
+    import_ansi_colors10 = __toESM(require("ansi-colors"), 1);
+    import_prompts6 = require("@clack/prompts");
+    init_prompt_utils();
+    init_fsModule_utils();
+    init_featureComponentGenerator_utils();
+    init_mvcModule_template();
+    capitalize20 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+    mvcModuleTemplate = async (featureName) => {
+      FeatureComponentGeneratorUtils.setStructure("mvc");
+      const basePath = import_path7.default.join("src", "features", featureName);
+      const paths = {
+        modelsDir: import_path7.default.join(basePath, "models"),
+        viewsDir: import_path7.default.join(basePath, "views"),
+        controllersDir: import_path7.default.join(basePath, "controllers"),
+        routesDir: import_path7.default.join(basePath, "routes")
+      };
+      Object.values(paths).forEach((dir) => UFsModule.createDirectoryRecursively(dir));
+      const controllerName = `${capitalize20(featureName)}Controller`;
+      UFsModule.createFile(import_path7.default.join(paths.modelsDir, `${featureName}.model.ts`), generateMvcModelTemplate(featureName));
+      console.log(import_ansi_colors10.default.green(`\u2705 Model created: ${import_path7.default.join(paths.modelsDir, `${featureName}.model.ts`)}`));
+      UFsModule.createFile(import_path7.default.join(paths.viewsDir, `${featureName}.view.ts`), generateMvcViewTemplate(featureName));
+      console.log(import_ansi_colors10.default.green(`\u2705 View created: ${import_path7.default.join(paths.viewsDir, `${featureName}.view.ts`)}`));
+      const wantsMethods = await UPrompt.confirm("Do you want to add methods to the controller?");
+      let methods = [];
+      let controllerContent;
+      if (wantsMethods && !(0, import_prompts6.isCancel)(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);
+        controllerContent = generateMvcControllerTemplate(controllerName, featureName, methods);
+      } else {
+        controllerContent = `import { Request, Response } from "opticore-express";
+
+export class ${controllerName} {}
+`;
+      }
+      const controllerPath = import_path7.default.join(paths.controllersDir, `${featureName}.controller.ts`);
+      UFsModule.createFile(controllerPath, controllerContent);
+      console.log(import_ansi_colors10.default.green(`\u2705 Controller created: ${controllerPath}`));
+      UFsModule.createFile(
+        import_path7.default.join(paths.routesDir, `${featureName}.router.handler.ts`),
+        generateMvcRouterHandlerTemplate(featureName, methods)
+      );
+      console.log(import_ansi_colors10.default.green(`\u2705 Router Handler created: ${import_path7.default.join(paths.routesDir, `${featureName}.router.handler.ts`)}`));
+      UFsModule.createFile(
+        import_path7.default.join(paths.routesDir, `${featureName}.router.ts`),
+        generateMvcRouterTemplate(featureName)
+      );
+      await FeatureComponentGeneratorUtils.registerModuleRouter(featureName);
+      console.log(import_ansi_colors10.default.green(`\u2705 Router created: ${import_path7.default.join(paths.routesDir, `${featureName}.router.ts`)}`));
+      console.log(
+        import_ansi_colors10.default.bgGreen(
+          import_ansi_colors10.default.white(`
+\u{1F389}  Feature "${featureName}" scaffolded with MVC architecture!
+`)
+        )
+      );
+    };
+  }
+});
+
+// src/templates/layeredModule/layeredModule.template.ts
+var capitalize21, generateLayeredEntityTemplate, generateLayeredDtoTemplate, generateLayeredRepositoryTemplate, generateLayeredServiceTemplate, generateLayeredControllerTemplate, generateMethod5, generateFindAllMethod4, generateFindByIdMethod4, generateCreateMethod4, generateUpdateMethod4, generateDeleteMethod4, generateLayeredRouterHandlerTemplate, generateLayeredRouterTemplate, resolveRoute4;
+var init_layeredModule_template = __esm({
+  "src/templates/layeredModule/layeredModule.template.ts"() {
+    "use strict";
+    init_cjs_shims();
+    capitalize21 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+    generateLayeredEntityTemplate = (featureName) => {
+      const capitalized = capitalize21(featureName);
+      const entityName = `${capitalized}Entity`;
+      return `/**
+ * ${entityName} \u2014 Entity
+ * Plain data structure for the "${featureName}" domain. No data-access logic here.
+ */
+export class ${entityName} {
+    constructor(
+        public readonly id: string,
+        // TODO: add your entity fields here
+        public readonly createdAt: Date = new Date(),
+        public readonly updatedAt: Date = new Date(),
+    ) {}
+}
+`;
+    };
+    generateLayeredDtoTemplate = (featureName) => {
+      const capitalized = capitalize21(featureName);
+      const entityName = `${capitalized}Entity`;
+      return `import { ${entityName} } from "../entities/${featureName}.entity";
+
+export interface Create${capitalized}Dto {
+    // TODO: define the fields required to create a ${featureName}
+}
+
+export interface Update${capitalized}Dto {
+    // TODO: define the fields that can be updated
+}
+
+export interface ${capitalized}ResponseDto {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    // TODO: define the fields exposed to API consumers
+}
+
+export const to${capitalized}ResponseDto = (entity: ${entityName}): ${capitalized}ResponseDto => ({
+    id: entity.id,
+    createdAt: entity.createdAt,
+    updatedAt: entity.updatedAt,
+});
+`;
+    };
+    generateLayeredRepositoryTemplate = (featureName) => {
+      const capitalized = capitalize21(featureName);
+      const entityName = `${capitalized}Entity`;
+      const repoName = `${capitalized}Repository`;
+      return `import { ${entityName} } from "../entities/${featureName}.entity";
+
+export class ${repoName} {
+    private store: Map<string, ${entityName}> = new Map();
+
+    async findAll(): Promise<${entityName}[]> {
+        // TODO: Replace with your ORM query
+        return Array.from(this.store.values());
+    }
+
+    async findById(id: string): Promise<${entityName} | null> {
+        // TODO: Replace with your ORM query
+        return this.store.get(id) ?? null;
+    }
+
+    async create(entity: ${entityName}): Promise<${entityName}> {
+        // TODO: Replace with your ORM save
+        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
+        return this.store.delete(id);
+    }
+}
+`;
+    };
+    generateLayeredServiceTemplate = (featureName) => {
+      const capitalized = capitalize21(featureName);
+      const entityName = `${capitalized}Entity`;
+      const repoName = `${capitalized}Repository`;
+      const serviceName = `${capitalized}Service`;
+      return `import { ${repoName} } from "../repositories/${featureName}.repository";
+import { ${entityName} } from "../entities/${featureName}.entity";
+import { Create${capitalized}Dto, Update${capitalized}Dto, ${capitalized}ResponseDto, to${capitalized}ResponseDto } from "../dto/${featureName}.dto";
+
+export class ${serviceName} {
+    private readonly repository: ${repoName};
+
+    constructor() {
+        this.repository = new ${repoName}();
+    }
+
+    async findAll(): Promise<${capitalized}ResponseDto[]> {
+        const entities = await this.repository.findAll();
+        return entities.map(to${capitalized}ResponseDto);
+    }
+
+    async findById(id: string): Promise<${capitalized}ResponseDto | null> {
+        const entity = await this.repository.findById(id);
+        return entity ? to${capitalized}ResponseDto(entity) : null;
+    }
+
+    async create(data: Create${capitalized}Dto): Promise<${capitalized}ResponseDto> {
+        const entity = new ${entityName}(String(Date.now()));
+        // TODO: Map data fields onto entity
+        const created = await this.repository.create(entity);
+        return to${capitalized}ResponseDto(created);
+    }
+
+    async update(id: string, data: Update${capitalized}Dto): Promise<${capitalized}ResponseDto | null> {
+        const existing = await this.repository.findById(id);
+        if (!existing) {
+            return null;
+        }
+        // TODO: Apply data fields onto existing entity
+        const updated = await this.repository.update(existing);
+        return updated ? to${capitalized}ResponseDto(updated) : null;
+    }
+
+    async delete(id: string): Promise<boolean> {
+        return this.repository.delete(id);
+    }
+}
+`;
+    };
+    generateLayeredControllerTemplate = (controllerName, featureName, methods) => {
+      const capitalized = capitalize21(featureName);
+      const serviceName = `${capitalized}Service`;
+      const methodsCode = methods.map((method) => generateMethod5(method, capitalized, serviceName)).join("\n");
+      return `import { Request, Response } from "opticore-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);
+    }
+}
+`;
+    };
+    generateMethod5 = (method, capitalized, serviceName) => {
+      const lower = method.toLowerCase();
+      if (lower.includes("findall") || lower.includes("getall")) return generateFindAllMethod4(method, capitalized);
+      if (lower.includes("findbyid") || lower.includes("getbyid") || lower.includes("getone")) return generateFindByIdMethod4(method, capitalized);
+      if (lower.includes("create") || lower.includes("add")) return generateCreateMethod4(method, capitalized);
+      if (lower.includes("update") || lower.includes("edit")) return generateUpdateMethod4(method, capitalized);
+      if (lower.includes("delete") || lower.includes("remove")) return generateDeleteMethod4(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);
+        }
+    }
+`;
+    };
+    generateFindAllMethod4 = (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);
+        }
+    }
+`;
+    generateFindByIdMethod4 = (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);
+        }
+    }
+`;
+    generateCreateMethod4 = (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);
+        }
+    }
+`;
+    generateUpdateMethod4 = (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);
+        }
+    }
+`;
+    generateDeleteMethod4 = (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);
+        }
+    }
+`;
+    generateLayeredRouterHandlerTemplate = (featureName, controllerMethods) => {
+      const capitalized = capitalize21(featureName);
+      const handlerName = `${capitalized}HandlerRouter`;
+      const controllerName = `${capitalized}Controller`;
+      const routesCode = (controllerMethods || []).map((method) => {
+        const { httpMethod, path: path10 } = resolveRoute4(method, featureName);
+        return `{
+    path: \`${path10}\`,
+    method: "${httpMethod}",
+    middlewares: [],
+    handler: async (ctx: ICustomContext) => await ${controllerName}.${method}(ctx.req, ctx.res)
+}`;
+      }).join(",\n");
+      return `import { OpticoreRoutingFactory, ICustomContext, IMultipleRouteDefinition } from "opticore-router";
+import { ${controllerName} } from "../controllers/${featureName}.controller";
+
+export const ${handlerName}: () => IMultipleRouteDefinition = () => {
+    return OpticoreRoutingFactory.routes(
+        ${controllerName},
+        [
+            ${routesCode.replace(/\n/g, "\n            ")}
+        ]
+    );
+};
+`;
+    };
+    generateLayeredRouterTemplate = (featureName) => {
+      const capitalized = capitalize21(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
+        }
+    ]
+};
+`;
+    };
+    resolveRoute4 = (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}` };
+    };
+  }
+});
+
+// src/templates/layeredModule/layeredModuleScaffold.template.ts
+var import_path8, import_ansi_colors11, import_prompts7, capitalize22, layeredModuleTemplate;
+var init_layeredModuleScaffold_template = __esm({
+  "src/templates/layeredModule/layeredModuleScaffold.template.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_path8 = __toESM(require("path"), 1);
+    import_ansi_colors11 = __toESM(require("ansi-colors"), 1);
+    import_prompts7 = require("@clack/prompts");
+    init_prompt_utils();
+    init_fsModule_utils();
+    init_featureComponentGenerator_utils();
+    init_layeredModule_template();
+    capitalize22 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+    layeredModuleTemplate = async (featureName) => {
+      FeatureComponentGeneratorUtils.setStructure("layered");
+      const basePath = import_path8.default.join("src", "features", featureName);
+      const paths = {
+        entitiesDir: import_path8.default.join(basePath, "entities"),
+        dtoDir: import_path8.default.join(basePath, "dto"),
+        repositoriesDir: import_path8.default.join(basePath, "repositories"),
+        servicesDir: import_path8.default.join(basePath, "services"),
+        controllersDir: import_path8.default.join(basePath, "controllers"),
+        routesDir: import_path8.default.join(basePath, "routes")
+      };
+      Object.values(paths).forEach((dir) => UFsModule.createDirectoryRecursively(dir));
+      const controllerName = `${capitalize22(featureName)}Controller`;
+      UFsModule.createFile(import_path8.default.join(paths.entitiesDir, `${featureName}.entity.ts`), generateLayeredEntityTemplate(featureName));
+      console.log(import_ansi_colors11.default.green(`\u2705 Entity created: ${import_path8.default.join(paths.entitiesDir, `${featureName}.entity.ts`)}`));
+      UFsModule.createFile(import_path8.default.join(paths.dtoDir, `${featureName}.dto.ts`), generateLayeredDtoTemplate(featureName));
+      console.log(import_ansi_colors11.default.green(`\u2705 DTO created: ${import_path8.default.join(paths.dtoDir, `${featureName}.dto.ts`)}`));
+      UFsModule.createFile(import_path8.default.join(paths.repositoriesDir, `${featureName}.repository.ts`), generateLayeredRepositoryTemplate(featureName));
+      console.log(import_ansi_colors11.default.green(`\u2705 Repository created: ${import_path8.default.join(paths.repositoriesDir, `${featureName}.repository.ts`)}`));
+      UFsModule.createFile(import_path8.default.join(paths.servicesDir, `${featureName}.service.ts`), generateLayeredServiceTemplate(featureName));
+      console.log(import_ansi_colors11.default.green(`\u2705 Service created: ${import_path8.default.join(paths.servicesDir, `${featureName}.service.ts`)}`));
+      const wantsMethods = await UPrompt.confirm("Do you want to add methods to the controller?");
+      let methods = [];
+      let controllerContent;
+      if (wantsMethods && !(0, import_prompts7.isCancel)(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);
+        controllerContent = generateLayeredControllerTemplate(controllerName, featureName, methods);
+      } else {
+        controllerContent = `import { Request, Response } from "opticore-express";
+
+export class ${controllerName} {}
+`;
+      }
+      const controllerPath = import_path8.default.join(paths.controllersDir, `${featureName}.controller.ts`);
+      UFsModule.createFile(controllerPath, controllerContent);
+      console.log(import_ansi_colors11.default.green(`\u2705 Controller created: ${controllerPath}`));
+      UFsModule.createFile(
+        import_path8.default.join(paths.routesDir, `${featureName}.router.handler.ts`),
+        generateLayeredRouterHandlerTemplate(featureName, methods)
+      );
+      console.log(import_ansi_colors11.default.green(`\u2705 Router Handler created: ${import_path8.default.join(paths.routesDir, `${featureName}.router.handler.ts`)}`));
+      UFsModule.createFile(
+        import_path8.default.join(paths.routesDir, `${featureName}.router.ts`),
+        generateLayeredRouterTemplate(featureName)
+      );
+      await FeatureComponentGeneratorUtils.registerModuleRouter(featureName);
+      console.log(import_ansi_colors11.default.green(`\u2705 Router created: ${import_path8.default.join(paths.routesDir, `${featureName}.router.ts`)}`));
+      console.log(
+        import_ansi_colors11.default.bgGreen(
+          import_ansi_colors11.default.white(`
+\u{1F389}  Feature "${featureName}" scaffolded with Layered architecture!
+`)
+        )
+      );
+    };
+  }
+});
+
 // src/core/core.ts
 var core_exports = {};
-var import_process2, import_node_fs2, import_path7, import_prompts6;
+var import_process2, import_node_fs2, import_path9, import_prompts8;
 var init_core = __esm({
   "src/core/core.ts"() {
     "use strict";
     init_cjs_shims();
     import_process2 = __toESM(require("process"), 1);
     import_node_fs2 = __toESM(require("fs"), 1);
-    import_path7 = __toESM(require("path"), 1);
-    import_prompts6 = require("@clack/prompts");
+    import_path9 = __toESM(require("path"), 1);
+    import_prompts8 = require("@clack/prompts");
     init_welcomeMessage_utils();
     init_choiceFeatureCleanModule();
     init_customFeatureInfo_utils();
@@ -2602,6 +3298,8 @@ var init_core = __esm({
     init_base_service();
     init_createController_application();
     init_customModuleScaffold_template();
+    init_mvcModuleScaffold_template();
+    init_layeredModuleScaffold_template();
     (async () => {
       UWelcomeMessage();
       const featureChoice = await choiceFeatureCleanModule();
@@ -2609,18 +3307,40 @@ var init_core = __esm({
         await customModuleScaffoldTemplate();
         return;
       }
+      if (featureChoice === "mvc_architecture" || featureChoice === "layered_architecture") {
+        const featureName2 = await _featureName();
+        const directory2 = import_path9.default.join(import_process2.default.cwd(), "src", "features");
+        const featureDirectory2 = import_path9.default.join(directory2, featureName2.toString());
+        if (BaseService._isSubdirectoryExists(featureName2)) {
+          BaseService._featureFounded(featureName2);
+        }
+        if ((0, import_prompts8.isCancel)(featureName2)) {
+          BaseService._cancelOperation(featureDirectory2);
+          return;
+        }
+        if (!import_node_fs2.default.existsSync(directory2)) {
+          BaseService._checkFeatureDir();
+          return;
+        }
+        if (featureChoice === "mvc_architecture") {
+          await mvcModuleTemplate(featureName2.toString());
+        } else {
+          await layeredModuleTemplate(featureName2.toString());
+        }
+        return;
+      }
       if (!featureChoice || featureChoice !== "opticore_clean_module") {
         import_process2.default.exit(0);
       }
       UCustomFeatureInfo(featureChoice);
       const featureName = await _featureName();
-      const directory = import_path7.default.join(import_process2.default.cwd(), "src", "features");
-      const featureDirectory = import_path7.default.join(directory, featureName.toString());
+      const directory = import_path9.default.join(import_process2.default.cwd(), "src", "features");
+      const featureDirectory = import_path9.default.join(directory, featureName.toString());
       const featureCleanModule = BaseService._isSubdirectoryExists(featureName);
       if (featureCleanModule) {
         BaseService._featureFounded(featureName);
       }
-      if ((0, import_prompts6.isCancel)(featureName)) {
+      if ((0, import_prompts8.isCancel)(featureName)) {
         BaseService._cancelOperation(featureDirectory);
       } else {
         try {