opticore-feature-component 1.0.4 → 1.0.6

package/dist/{core-GNR24GXE.js → core-TFP6J3AE.js}

@@ -1,8 +1,8 @@
 // src/core/core.ts
 import process3 from "process";
 import fs5 from "fs";
-import path7 from "path";
-import { isCancel as isCancel5 } from "@clack/prompts";
+import path9 from "path";
+import { isCancel as isCancel7 } from "@clack/prompts";
 
 // src/utils/welcomeMessage.utils.ts
 import cfonts from "cfonts";
@@ -126,7 +126,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 (isCancel(featureSelected)) {
@@ -877,19 +879,19 @@ var generateRouterHandlerTemplate = (featureName, controllerMethods) => {
   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            ")}
@@ -1397,19 +1399,19 @@ var generateSimpleRouterHandlerTemplate = (featureName, controllerMethods) => {
   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            ")}
@@ -1647,7 +1649,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 (!fs3.existsSync(this.REGISTER_ROUTER_PATH)) {
@@ -2142,19 +2144,19 @@ var generateCustomRouterHandlerTemplate = (moduleName, controllerMethods) => {
   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            ") : ""}
@@ -2290,6 +2292,668 @@ ${colors9.bgGreen(colors9.white(`
 `))}`);
 };
 
+// src/templates/mvcModule/mvcModuleScaffold.template.ts
+import path7 from "path";
+import colors10 from "ansi-colors";
+import { isCancel as isCancel5 } from "@clack/prompts";
+
+// src/templates/mvcModule/mvcModule.template.ts
+var capitalize19 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+var 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);
+    }
+}
+`;
+};
+var 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));
+    }
+}
+`;
+};
+var 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);
+    }
+}
+`;
+};
+var 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);
+        }
+    }
+`;
+};
+var 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);
+        }
+    }
+`;
+var 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);
+        }
+    }
+`;
+var 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);
+        }
+    }
+`;
+var 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);
+        }
+    }
+`;
+var 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);
+        }
+    }
+`;
+var 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            ")}
+        ]
+    );
+};
+`;
+};
+var 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
+        }
+    ]
+};
+`;
+};
+var 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 capitalize20 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+var mvcModuleTemplate = async (featureName) => {
+  FeatureComponentGeneratorUtils.setStructure("mvc");
+  const basePath = path7.join("src", "features", featureName);
+  const paths = {
+    modelsDir: path7.join(basePath, "models"),
+    viewsDir: path7.join(basePath, "views"),
+    controllersDir: path7.join(basePath, "controllers"),
+    routesDir: path7.join(basePath, "routes")
+  };
+  Object.values(paths).forEach((dir) => UFsModule.createDirectoryRecursively(dir));
+  const controllerName = `${capitalize20(featureName)}Controller`;
+  UFsModule.createFile(path7.join(paths.modelsDir, `${featureName}.model.ts`), generateMvcModelTemplate(featureName));
+  console.log(colors10.green(`\u2705 Model created: ${path7.join(paths.modelsDir, `${featureName}.model.ts`)}`));
+  UFsModule.createFile(path7.join(paths.viewsDir, `${featureName}.view.ts`), generateMvcViewTemplate(featureName));
+  console.log(colors10.green(`\u2705 View created: ${path7.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 && !isCancel5(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 = path7.join(paths.controllersDir, `${featureName}.controller.ts`);
+  UFsModule.createFile(controllerPath, controllerContent);
+  console.log(colors10.green(`\u2705 Controller created: ${controllerPath}`));
+  UFsModule.createFile(
+    path7.join(paths.routesDir, `${featureName}.router.handler.ts`),
+    generateMvcRouterHandlerTemplate(featureName, methods)
+  );
+  console.log(colors10.green(`\u2705 Router Handler created: ${path7.join(paths.routesDir, `${featureName}.router.handler.ts`)}`));
+  UFsModule.createFile(
+    path7.join(paths.routesDir, `${featureName}.router.ts`),
+    generateMvcRouterTemplate(featureName)
+  );
+  await FeatureComponentGeneratorUtils.registerModuleRouter(featureName);
+  console.log(colors10.green(`\u2705 Router created: ${path7.join(paths.routesDir, `${featureName}.router.ts`)}`));
+  console.log(
+    colors10.bgGreen(
+      colors10.white(`
+\u{1F389}  Feature "${featureName}" scaffolded with MVC architecture!
+`)
+    )
+  );
+};
+
+// src/templates/layeredModule/layeredModuleScaffold.template.ts
+import path8 from "path";
+import colors11 from "ansi-colors";
+import { isCancel as isCancel6 } from "@clack/prompts";
+
+// src/templates/layeredModule/layeredModule.template.ts
+var capitalize21 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+var 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(),
+    ) {}
+}
+`;
+};
+var 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,
+});
+`;
+};
+var 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);
+    }
+}
+`;
+};
+var 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);
+    }
+}
+`;
+};
+var 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);
+    }
+}
+`;
+};
+var 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);
+        }
+    }
+`;
+};
+var 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);
+        }
+    }
+`;
+var 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);
+        }
+    }
+`;
+var 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);
+        }
+    }
+`;
+var 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);
+        }
+    }
+`;
+var 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);
+        }
+    }
+`;
+var 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            ")}
+        ]
+    );
+};
+`;
+};
+var 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
+        }
+    ]
+};
+`;
+};
+var 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 capitalize22 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+var layeredModuleTemplate = async (featureName) => {
+  FeatureComponentGeneratorUtils.setStructure("layered");
+  const basePath = path8.join("src", "features", featureName);
+  const paths = {
+    entitiesDir: path8.join(basePath, "entities"),
+    dtoDir: path8.join(basePath, "dto"),
+    repositoriesDir: path8.join(basePath, "repositories"),
+    servicesDir: path8.join(basePath, "services"),
+    controllersDir: path8.join(basePath, "controllers"),
+    routesDir: path8.join(basePath, "routes")
+  };
+  Object.values(paths).forEach((dir) => UFsModule.createDirectoryRecursively(dir));
+  const controllerName = `${capitalize22(featureName)}Controller`;
+  UFsModule.createFile(path8.join(paths.entitiesDir, `${featureName}.entity.ts`), generateLayeredEntityTemplate(featureName));
+  console.log(colors11.green(`\u2705 Entity created: ${path8.join(paths.entitiesDir, `${featureName}.entity.ts`)}`));
+  UFsModule.createFile(path8.join(paths.dtoDir, `${featureName}.dto.ts`), generateLayeredDtoTemplate(featureName));
+  console.log(colors11.green(`\u2705 DTO created: ${path8.join(paths.dtoDir, `${featureName}.dto.ts`)}`));
+  UFsModule.createFile(path8.join(paths.repositoriesDir, `${featureName}.repository.ts`), generateLayeredRepositoryTemplate(featureName));
+  console.log(colors11.green(`\u2705 Repository created: ${path8.join(paths.repositoriesDir, `${featureName}.repository.ts`)}`));
+  UFsModule.createFile(path8.join(paths.servicesDir, `${featureName}.service.ts`), generateLayeredServiceTemplate(featureName));
+  console.log(colors11.green(`\u2705 Service created: ${path8.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 && !isCancel6(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 = path8.join(paths.controllersDir, `${featureName}.controller.ts`);
+  UFsModule.createFile(controllerPath, controllerContent);
+  console.log(colors11.green(`\u2705 Controller created: ${controllerPath}`));
+  UFsModule.createFile(
+    path8.join(paths.routesDir, `${featureName}.router.handler.ts`),
+    generateLayeredRouterHandlerTemplate(featureName, methods)
+  );
+  console.log(colors11.green(`\u2705 Router Handler created: ${path8.join(paths.routesDir, `${featureName}.router.handler.ts`)}`));
+  UFsModule.createFile(
+    path8.join(paths.routesDir, `${featureName}.router.ts`),
+    generateLayeredRouterTemplate(featureName)
+  );
+  await FeatureComponentGeneratorUtils.registerModuleRouter(featureName);
+  console.log(colors11.green(`\u2705 Router created: ${path8.join(paths.routesDir, `${featureName}.router.ts`)}`));
+  console.log(
+    colors11.bgGreen(
+      colors11.white(`
+\u{1F389}  Feature "${featureName}" scaffolded with Layered architecture!
+`)
+    )
+  );
+};
+
 // src/core/core.ts
 (async () => {
   UWelcomeMessage();
@@ -2298,18 +2962,40 @@ ${colors9.bgGreen(colors9.white(`
     await customModuleScaffoldTemplate();
     return;
   }
+  if (featureChoice === "mvc_architecture" || featureChoice === "layered_architecture") {
+    const featureName2 = await _featureName();
+    const directory2 = path9.join(process3.cwd(), "src", "features");
+    const featureDirectory2 = path9.join(directory2, featureName2.toString());
+    if (BaseService._isSubdirectoryExists(featureName2)) {
+      BaseService._featureFounded(featureName2);
+    }
+    if (isCancel7(featureName2)) {
+      BaseService._cancelOperation(featureDirectory2);
+      return;
+    }
+    if (!fs5.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") {
     process3.exit(0);
   }
   UCustomFeatureInfo(featureChoice);
   const featureName = await _featureName();
-  const directory = path7.join(process3.cwd(), "src", "features");
-  const featureDirectory = path7.join(directory, featureName.toString());
+  const directory = path9.join(process3.cwd(), "src", "features");
+  const featureDirectory = path9.join(directory, featureName.toString());
   const featureCleanModule = BaseService._isSubdirectoryExists(featureName);
   if (featureCleanModule) {
     BaseService._featureFounded(featureName);
   }
-  if (isCancel5(featureName)) {
+  if (isCancel7(featureName)) {
     BaseService._cancelOperation(featureDirectory);
   } else {
     try {