create-flex-stack 1.0.0

package/dist/templates/hexagonalTemplate.js

@@ -0,0 +1,855 @@
+import { getTypeOrmConfig, getTypeOrmEntity } from './sharedTemplate.js';
+export function getHexagonalFiles(options) {
+    const files = {};
+    const userIdExpr = options.orm === 'prisma' ? 'user.id' : 'user._id.toString()';
+    // 1. Config & Env
+    files['src/config/env.ts'] = options.validation === 'zod'
+        ? `import dotenv from 'dotenv';
+import { z } from 'zod';
+
+dotenv.config();
+
+const envSchema = z.object({
+  PORT: z.coerce.number().default(3000),
+  DATABASE_URL: z.string().min(1),
+  ${options.auth ? `JWT_SECRET: z.string().min(8),
+  JWT_REFRESH_SECRET: z.string().min(8),
+  JWT_EXPIRES_IN: z.string().default('15m'),
+  JWT_REFRESH_EXPIRES_IN: z.string().default('7d'),` : ''}
+  ${options.caching ? `REDIS_URL: z.string().min(1),` : ''}
+});
+
+const parsed = envSchema.safeParse(process.env);
+if (!parsed.success) {
+  console.error('❌ Invalid environment variables:', parsed.error.format());
+  process.exit(1);
+}
+export const env = parsed.data;
+`
+        : `import dotenv from 'dotenv';
+import Joi from 'joi';
+
+dotenv.config();
+
+const envSchema = Joi.object({
+  PORT: Joi.number().default(3000),
+  DATABASE_URL: Joi.string().required(),
+  ${options.auth ? `JWT_SECRET: Joi.string().min(8).required(),
+  JWT_REFRESH_SECRET: Joi.string().min(8).required(),
+  JWT_EXPIRES_IN: Joi.string().default('15m'),
+  JWT_REFRESH_EXPIRES_IN: Joi.string().default('7d'),` : ''}
+  ${options.caching ? `REDIS_URL: Joi.string().required(),` : ''}
+}).unknown().required();
+
+const { error, value } = envSchema.validate(process.env);
+if (error) {
+  console.error('❌ Invalid environment variables:', error.message);
+  process.exit(1);
+}
+export const env = {
+  PORT: Number(value.PORT),
+  DATABASE_URL: value.DATABASE_URL,
+  ${options.auth ? `JWT_SECRET: value.JWT_SECRET,
+  JWT_REFRESH_SECRET: value.JWT_REFRESH_SECRET,
+  JWT_EXPIRES_IN: value.JWT_EXPIRES_IN,
+  JWT_REFRESH_EXPIRES_IN: value.JWT_REFRESH_EXPIRES_IN,` : ''}
+  ${options.caching ? `REDIS_URL: value.REDIS_URL,` : ''}
+};
+`;
+    if (options.orm === 'typeorm') {
+        files['src/config/data-source.ts'] = getTypeOrmConfig(options)
+            .replace('../entities/user.entity.js', '../adapters/outbound/db/user.entity.js');
+    }
+    // 2. Domain Models
+    files['src/domain/models/user.model.ts'] = `export class User {
+  constructor(
+    public readonly id: string,
+    public readonly email: string,
+    public readonly password: string,
+    public readonly name: string | null,
+    public readonly role: string,
+    public readonly createdAt: Date,
+    public readonly refreshToken: string | null = null
+  ) {}
+}
+`;
+    // 3. Ports
+    // Outbound Ports (Driven ports)
+    files['src/ports/outbound/user-repository.port.ts'] = `import { User } from '../../domain/models/user.model.js';
+
+export interface IUserRepositoryPort {
+  findByEmail(email: string): Promise<User | null>;
+  findById(id: string): Promise<User | null>;
+  create(user: Omit<User, 'id' | 'createdAt'>): Promise<User>;
+  update(id: string, user: Partial<User>): Promise<User>;
+  delete(id: string): Promise<void>;
+  findAll(): Promise<Omit<User, 'password' | 'refreshToken'>[]>;
+}
+`;
+    files['src/ports/outbound/password-hasher.port.ts'] = `export interface IPasswordHasherPort {
+  hash(password: string): Promise<string>;
+  compare(raw: string, hashed: string): Promise<boolean>;
+}
+`;
+    files['src/ports/outbound/token-service.port.ts'] = `export interface ITokenServicePort {
+  generateTokens(payload: { id: string; email: string; role: string }): { accessToken: string; refreshToken: string };
+  verifyRefreshToken(token: string): any;
+}
+`;
+    // Inbound Ports (Driving ports / Usecase boundaries)
+    files['src/ports/inbound/user-usecase.port.ts'] = `import { User } from '../../domain/models/user.model.js';
+
+export interface IRegisterUserPort {
+  execute(input: any): Promise<any>;
+}
+
+export interface ILoginUserPort {
+  execute(input: any): Promise<any>;
+}
+
+export interface IGetUserProfilePort {
+  execute(userId: string): Promise<any>;
+}
+
+export interface IRefreshTokenPort {
+  execute(token: string): Promise<any>;
+}
+`;
+    // 4. Application Services (Implements Inbound Ports, delegates to Outbound Ports)
+    files['src/application/use-cases/auth.use-cases.ts'] = `import { User } from '../../domain/models/user.model.js';
+import { IUserRepositoryPort } from '../../ports/outbound/user-repository.port.js';
+import { IPasswordHasherPort } from '../../ports/outbound/password-hasher.port.js';
+import { ITokenServicePort } from '../../ports/outbound/token-service.port.js';
+import {
+  IRegisterUserPort,
+  ILoginUserPort,
+  IGetUserProfilePort,
+  IRefreshTokenPort
+} from '../../ports/inbound/user-usecase.port.js';
+
+export class RegisterUserUseCase implements IRegisterUserPort {
+  constructor(
+    private userRepo: IUserRepositoryPort,
+    private hasher: IPasswordHasherPort,
+    private tokenService: ITokenServicePort
+  ) {}
+
+  async execute(input: any) {
+    const existing = await this.userRepo.findByEmail(input.email);
+    if (existing) throw new Error('Email already registered');
+
+    const hashedPassword = await this.hasher.hash(input.password);
+    const user = await this.userRepo.create({
+      email: input.email,
+      name: input.name || null,
+      password: hashedPassword,
+      role: input.role || 'user',
+      refreshToken: null
+    });
+
+    const tokens = this.tokenService.generateTokens({ id: user.id, email: user.email, role: user.role });
+    await this.userRepo.update(user.id, { refreshToken: tokens.refreshToken });
+
+    return {
+      user: { id: user.id, email: user.email, name: user.name, role: user.role },
+      ...tokens
+    };
+  }
+}
+
+export class LoginUserUseCase implements ILoginUserPort {
+  constructor(
+    private userRepo: IUserRepositoryPort,
+    private hasher: IPasswordHasherPort,
+    private tokenService: ITokenServicePort
+  ) {}
+
+  async execute(input: any) {
+    const user = await this.userRepo.findByEmail(input.email);
+    if (!user) throw new Error('Invalid email or password');
+
+    const isMatch = await this.hasher.compare(input.password, user.password);
+    if (!isMatch) throw new Error('Invalid email or password');
+
+    const tokens = this.tokenService.generateTokens({ id: user.id, email: user.email, role: user.role });
+    await this.userRepo.update(user.id, { refreshToken: tokens.refreshToken });
+
+    return {
+      user: { id: user.id, email: user.email, name: user.name, role: user.role },
+      ...tokens
+    };
+  }
+}
+
+export class GetUserProfileUseCase implements IGetUserProfilePort {
+  constructor(private userRepo: IUserRepositoryPort) {}
+
+  async execute(userId: string) {
+    const user = await this.userRepo.findById(userId);
+    if (!user) throw new Error('User not found');
+    return {
+      id: user.id,
+      email: user.email,
+      name: user.name,
+      role: user.role,
+      createdAt: user.createdAt
+    };
+  }
+}
+
+export class RefreshTokenUseCase implements IRefreshTokenPort {
+  constructor(
+    private userRepo: IUserRepositoryPort,
+    private tokenService: ITokenServicePort
+  ) {}
+
+  async execute(token: string) {
+    try {
+      const decoded = this.tokenService.verifyRefreshToken(token);
+      const user = await this.userRepo.findById(decoded.id);
+      if (!user || user.refreshToken !== token) {
+        throw new Error('Invalid or revoked refresh token');
+      }
+
+      const tokens = this.tokenService.generateTokens({ id: user.id, email: user.email, role: user.role });
+      await this.userRepo.update(user.id, { refreshToken: tokens.refreshToken });
+      return tokens;
+    } catch (err) {
+      throw new Error('Invalid or expired refresh token');
+    }
+  }
+}
+`;
+    // 5. Adapters
+    // Outbound Adapters (Security)
+    files['src/adapters/outbound/security/bcrypt.hasher.ts'] = `import bcrypt from 'bcryptjs';
+import { IPasswordHasherPort } from '../../../ports/outbound/password-hasher.port.js';
+
+export class BcryptPasswordHasher implements IPasswordHasherPort {
+  async hash(password: string): Promise<string> {
+    return bcrypt.hash(password, 10);
+  }
+  async compare(raw: string, hashed: string): Promise<boolean> {
+    return bcrypt.compare(raw, hashed);
+  }
+}
+`;
+    files['src/adapters/outbound/security/jwt.token-generator.ts'] = `import jwt from 'jsonwebtoken';
+import { ITokenServicePort } from '../../../ports/outbound/token-service.port.js';
+import { env } from '../../../config/env.js';
+
+export class JwtTokenService implements ITokenServicePort {
+  generateTokens(payload: { id: string; email: string; role: string }) {
+    const accessToken = jwt.sign(payload, env.JWT_SECRET, { expiresIn: env.JWT_EXPIRES_IN as any });
+    const refreshToken = jwt.sign(payload, env.JWT_REFRESH_SECRET, { expiresIn: env.JWT_REFRESH_EXPIRES_IN as any });
+    return { accessToken, refreshToken };
+  }
+  verifyRefreshToken(token: string) {
+    return jwt.verify(token, env.JWT_REFRESH_SECRET);
+  }
+}
+`;
+    // Outbound Adapters (Database entity if TypeORM)
+    if (options.orm === 'typeorm') {
+        files['src/adapters/outbound/db/user.entity.ts'] = getTypeOrmEntity();
+    }
+    else if (options.orm === 'mongoose') {
+        files['src/adapters/outbound/db/user.model.ts'] = `import mongoose, { Schema } from 'mongoose';
+
+const UserSchema = new Schema({
+  email: { type: String, required: true, unique: true },
+  name: { type: String },
+  password: { type: String, required: true },
+  role: { type: String, default: 'user' },
+  refreshToken: { type: String },
+}, { timestamps: true });
+
+export const UserModel = mongoose.models.User || mongoose.model('User', UserSchema);
+`;
+    }
+    // Outbound Adapters (Database repo implementing Outbound Port)
+    if (options.orm === 'prisma') {
+        files['src/adapters/outbound/db/orm-user.repository.ts'] = `import { PrismaClient } from '@prisma/client';
+import { IUserRepositoryPort } from '../../../ports/outbound/user-repository.port.js';
+import { User } from '../../../domain/models/user.model.js';
+
+const prisma = new PrismaClient();
+
+export class OrmUserRepository implements IUserRepositoryPort {
+  private mapToModel(u: any): User {
+    return new User(u.id, u.email, u.password, u.name, u.role, u.createdAt, u.refreshToken);
+  }
+
+  async findByEmail(email: string): Promise<User | null> {
+    const u = await prisma.user.findUnique({ where: { email } });
+    return u ? this.mapToModel(u) : null;
+  }
+  async findById(id: string): Promise<User | null> {
+    const u = await prisma.user.findUnique({ where: { id } });
+    return u ? this.mapToModel(u) : null;
+  }
+  async create(user: Omit<User, 'id' | 'createdAt'>): Promise<User> {
+    const created = await prisma.user.create({ data: user });
+    return this.mapToModel(created);
+  }
+  async update(id: string, user: Partial<User>): Promise<User> {
+    const updated = await prisma.user.update({ where: { id }, data: user });
+    return this.mapToModel(updated);
+  }
+  async delete(id: string): Promise<void> {
+    await prisma.user.delete({ where: { id } });
+  }
+  async findAll(): Promise<Omit<User, 'password' | 'refreshToken'>[]> {
+    const users = await prisma.user.findMany();
+    return users.map(u => ({ id: u.id, email: u.email, name: u.name, role: u.role, createdAt: u.createdAt }));
+  }
+}
+`;
+    }
+    else if (options.orm === 'typeorm') {
+        files['src/adapters/outbound/db/orm-user.repository.ts'] = `import { AppDataSource } from '../../../config/data-source.js';
+import { UserEntity } from './user.entity.js';
+import { IUserRepositoryPort } from '../../../ports/outbound/user-repository.port.js';
+import { User } from '../../../domain/models/user.model.js';
+
+export class OrmUserRepository implements IUserRepositoryPort {
+  private repo = AppDataSource.getRepository(UserEntity);
+
+  private mapToModel(u: UserEntity): User {
+    return new User(u.id, u.email, u.password, u.name ?? null, u.role, u.createdAt, u.refreshToken ?? null);
+  }
+
+  async findByEmail(email: string): Promise<User | null> {
+    const u = await this.repo.findOne({ where: { email } });
+    return u ? this.mapToModel(u) : null;
+  }
+  async findById(id: string): Promise<User | null> {
+    const u = await this.repo.findOne({ where: { id } });
+    return u ? this.mapToModel(u) : null;
+  }
+  async create(user: Omit<User, 'id' | 'createdAt'>): Promise<User> {
+    const created = this.repo.create({
+      email: user.email,
+      name: user.name ?? undefined,
+      password: user.password,
+      role: user.role,
+      refreshToken: user.refreshToken ?? undefined,
+    });
+    const saved = await this.repo.save(created);
+    return this.mapToModel(saved);
+  }
+  async update(id: string, user: Partial<User>): Promise<User> {
+    await this.repo.update(id, {
+      email: user.email,
+      name: user.name ?? undefined,
+      password: user.password,
+      role: user.role,
+      refreshToken: user.refreshToken ?? undefined,
+    });
+    const updated = await this.findById(id);
+    return updated!;
+  }
+  async delete(id: string): Promise<void> {
+    await this.repo.delete(id);
+  }
+  async findAll(): Promise<Omit<User, 'password' | 'refreshToken'>[]> {
+    const list = await this.repo.find();
+    return list.map(u => ({ id: u.id, email: u.email, name: u.name ?? null, role: u.role, createdAt: u.createdAt }));
+  }
+}
+`;
+    }
+    else {
+        // Mongoose
+        files['src/adapters/outbound/db/orm-user.repository.ts'] = `import { UserModel } from './user.model.js';
+import { IUserRepositoryPort } from '../../../ports/outbound/user-repository.port.js';
+import { User } from '../../../domain/models/user.model.js';
+
+export class OrmUserRepository implements IUserRepositoryPort {
+  private mapToModel(doc: any): User {
+    return new User(doc._id.toString(), doc.email, doc.password, doc.name, doc.role, doc.createdAt, doc.refreshToken);
+  }
+
+  async findByEmail(email: string): Promise<User | null> {
+    const doc = await UserModel.findOne({ email });
+    return doc ? this.mapToModel(doc) : null;
+  }
+  async findById(id: string): Promise<User | null> {
+    const doc = await UserModel.findById(id);
+    return doc ? this.mapToModel(doc) : null;
+  }
+  async create(user: Omit<User, 'id' | 'createdAt'>): Promise<User> {
+    const doc = await UserModel.create(user);
+    return this.mapToModel(doc);
+  }
+  async update(id: string, user: Partial<User>): Promise<User> {
+    const doc = await UserModel.findByIdAndUpdate(id, { $set: user }, { new: true });
+    return this.mapToModel(doc);
+  }
+  async delete(id: string): Promise<void> {
+    await UserModel.findByIdAndDelete(id);
+  }
+  async findAll(): Promise<Omit<User, 'password' | 'refreshToken'>[]> {
+    const docs = await UserModel.find({});
+    return docs.map(d => ({ id: d._id.toString(), email: d.email, name: d.name, role: d.role, createdAt: d.createdAt }));
+  }
+}
+`;
+    }
+    // Inbound Adapters (Web Middlewares)
+    files['src/adapters/inbound/web/middlewares/error.middleware.ts'] = `import { Request, Response, NextFunction } from 'express';
+
+export class AppError extends Error {
+  constructor(public statusCode: number, message: string) {
+    super(message);
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+export const errorHandler = (err: Error | AppError, req: Request, res: Response, next: NextFunction) => {
+  const statusCode = err instanceof AppError ? err.statusCode : 500;
+  res.status(statusCode).json({
+    status: 'error',
+    statusCode,
+    message: err.message || 'Internal Server Error'
+  });
+};
+`;
+    files['src/adapters/inbound/web/middlewares/auth.middleware.ts'] = `import { Request, Response, NextFunction } from 'express';
+import jwt from 'jsonwebtoken';
+import { env } from '../../../../config/env.js';
+import { AppError } from './error.middleware.js';
+
+export interface AuthenticatedRequest extends Request {
+  user?: { id: string; email: string; role: string };
+}
+
+export const requireAuth = (req: AuthenticatedRequest, res: Response, next: NextFunction) => {
+  const authHeader = req.headers.authorization;
+  if (!authHeader || !authHeader.startsWith('Bearer ')) {
+    return next(new AppError(401, 'Auth token missing'));
+  }
+  const token = authHeader.split(' ')[1];
+  try {
+    req.user = jwt.verify(token, env.JWT_SECRET) as any;
+    next();
+  } catch (error) {
+    next(new AppError(401, 'Token expired or corrupt'));
+  }
+};
+`;
+    if (options.rbac) {
+        files['src/adapters/inbound/web/middlewares/rbac.middleware.ts'] = `import { Response, NextFunction } from 'express';
+import { AuthenticatedRequest } from './auth.middleware.js';
+import { AppError } from './error.middleware.js';
+
+export const authorize = (...roles: string[]) => {
+  return (req: AuthenticatedRequest, res: Response, next: NextFunction) => {
+    if (!req.user || !roles.includes(req.user.role)) {
+      return next(new AppError(403, 'Permission denied'));
+    }
+    next();
+  };
+};
+`;
+    }
+    if (options.rateLimiting) {
+        files['src/adapters/inbound/web/middlewares/rateLimit.middleware.ts'] = `import rateLimit from 'express-rate-limit';
+
+export const apiLimiter = rateLimit({
+  windowMs: 15 * 60 * 1000,
+  max: 100,
+  message: { status: 'error', statusCode: 429, message: 'Too many requests' }
+});
+`;
+    }
+    // Request Validation Middleware & Schemas
+    files['src/adapters/inbound/web/middlewares/validate.middleware.ts'] = options.validation === 'zod'
+        ? `import { Request, Response, NextFunction } from 'express';
+import { AnyZodObject, ZodError } from 'zod';
+
+export const validate = (schema: AnyZodObject) => {
+  return async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const parsed = await schema.parseAsync({ body: req.body, query: req.query, params: req.params });
+      req.body = parsed.body;
+      next();
+    } catch (error) {
+      if (error instanceof ZodError) {
+        res.status(400).json({ status: 'error', statusCode: 400, message: 'Validation failed', errors: error.errors });
+      } else next(error);
+    }
+  };
+};
+`
+        : `import { Request, Response, NextFunction } from 'express';
+import { Schema } from 'joi';
+
+export const validate = (schema: Schema) => {
+  return async (req: Request, res: Response, next: NextFunction) => {
+    const { error, value } = schema.validate({ body: req.body, query: req.query, params: req.params }, { abortEarly: false });
+    if (error) {
+      return res.status(400).json({ status: 'error', statusCode: 400, message: 'Validation failed', errors: error.details });
+    }
+    req.body = value.body;
+    next();
+  };
+};
+`;
+    if (options.validation === 'zod') {
+        files['src/adapters/inbound/web/schemas/user.schema.ts'] = `import { z } from 'zod';
+
+export const registerSchema = z.object({
+  body: z.object({
+    email: z.string().email(),
+    password: z.string().min(6),
+    name: z.string().optional(),
+    role: z.enum(['user', 'admin']).optional(),
+  }),
+});
+
+export const loginSchema = z.object({
+  body: z.object({
+    email: z.string().email(),
+    password: z.string().min(1),
+  }),
+});
+
+export const refreshSchema = z.object({
+  body: z.object({
+    refreshToken: z.string().min(1),
+  }),
+});
+`;
+    }
+    else {
+        files['src/adapters/inbound/web/schemas/user.schema.ts'] = `import Joi from 'joi';
+
+export const registerSchema = Joi.object({
+  body: Joi.object({
+    email: Joi.string().email().required(),
+    password: Joi.string().min(6).required(),
+    name: Joi.string().optional(),
+    role: Joi.string().valid('user', 'admin').default('user'),
+  }).required(),
+}).unknown(true);
+
+export const loginSchema = Joi.object({
+  body: Joi.object({
+    email: Joi.string().email().required(),
+    password: Joi.string().required(),
+  }).required(),
+}).unknown(true);
+
+export const refreshSchema = Joi.object({
+  body: Joi.object({
+    refreshToken: Joi.string().required(),
+  }).required(),
+}).unknown(true);
+`;
+    }
+    // Web Controllers (HTTP driving adapter)
+    files['src/adapters/inbound/web/handlers/user.handler.ts'] = `import { Request, Response, NextFunction } from 'express';
+import { RegisterUserUseCase, LoginUserUseCase, GetUserProfileUseCase, RefreshTokenUseCase } from '../../../../application/use-cases/auth.use-cases.js';
+import { OrmUserRepository } from '../../../outbound/db/orm-user.repository.js';
+import { BcryptPasswordHasher } from '../../../outbound/security/bcrypt.hasher.js';
+import { JwtTokenService } from '../../../outbound/security/jwt.token-generator.js';
+import { AuthenticatedRequest } from '../middlewares/auth.middleware.js';
+
+const userRepo = new OrmUserRepository();
+const hasher = new BcryptPasswordHasher();
+const tokenService = new JwtTokenService();
+
+export class UserHandler {
+  async register(req: Request, res: Response, next: NextFunction) {
+    try {
+      const useCase = new RegisterUserUseCase(userRepo, hasher, tokenService);
+      const result = await useCase.execute(req.body);
+      res.status(201).json({ status: 'success', data: result });
+    } catch (err: any) {
+      res.status(400).json({ status: 'error', statusCode: 400, message: err.message });
+    }
+  }
+
+  async login(req: Request, res: Response, next: NextFunction) {
+    try {
+      const useCase = new LoginUserUseCase(userRepo, hasher, tokenService);
+      const result = await useCase.execute(req.body);
+      res.status(200).json({ status: 'success', data: result });
+    } catch (err: any) {
+      res.status(401).json({ status: 'error', statusCode: 401, message: err.message });
+    }
+  }
+
+  async refresh(req: Request, res: Response, next: NextFunction) {
+    try {
+      const useCase = new RefreshTokenUseCase(userRepo, tokenService);
+      const result = await useCase.execute(req.body.refreshToken);
+      res.status(200).json({ status: 'success', data: result });
+    } catch (err: any) {
+      res.status(401).json({ status: 'error', statusCode: 401, message: err.message });
+    }
+  }
+
+  async profile(req: AuthenticatedRequest, res: Response, next: NextFunction) {
+    try {
+      const useCase = new GetUserProfileUseCase(userRepo);
+      const user = await useCase.execute(req.user!.id);
+      res.status(200).json({ status: 'success', data: { user } });
+    } catch (err: any) {
+      res.status(404).json({ status: 'error', statusCode: 404, message: err.message });
+    }
+  }
+
+  async list(req: Request, res: Response, next: NextFunction) {
+    try {
+      const list = await userRepo.findAll();
+      res.status(200).json({ status: 'success', data: { users: list } });
+    } catch (err: any) {
+      next(err);
+    }
+  }
+
+  async show(req: Request, res: Response, next: NextFunction) {
+    try {
+      const user = await userRepo.findById(req.params.id);
+      if (!user) {
+        return res.status(404).json({ status: 'error', statusCode: 404, message: 'User not found' });
+      }
+      res.status(200).json({ status: 'success', data: { user } });
+    } catch (err: any) {
+      next(err);
+    }
+  }
+
+  async update(req: Request, res: Response, next: NextFunction) {
+    try {
+      const user = await userRepo.update(req.params.id, req.body);
+      res.status(200).json({ status: 'success', data: { user } });
+    } catch (err: any) {
+      next(err);
+    }
+  }
+
+  async remove(req: Request, res: Response, next: NextFunction) {
+    try {
+      await userRepo.delete(req.params.id);
+      res.status(204).send();
+    } catch (err: any) {
+      next(err);
+    }
+  }
+}
+`;
+    // Web Routes (HTTP driving adapter)
+    files['src/adapters/inbound/web/routes/user.routes.ts'] = `import { Router } from 'express';
+import { UserHandler } from '../handlers/user.handler.js';
+import { requireAuth } from '../middlewares/auth.middleware.js';
+${options.rbac ? `import { authorize } from '../middlewares/rbac.middleware.js';` : ''}
+import { validate } from '../middlewares/validate.middleware.js';
+import { registerSchema, loginSchema, refreshSchema } from '../schemas/user.schema.js';
+
+const router = Router();
+const handler = new UserHandler();
+
+router.post('/register', validate(registerSchema), handler.register);
+router.post('/login', validate(loginSchema), handler.login);
+router.post('/refresh', validate(refreshSchema), handler.refresh);
+router.get('/profile', requireAuth, handler.profile);
+router.get('/', requireAuth${options.rbac ? `, authorize('admin')` : ''}, handler.list);
+router.post('/', requireAuth${options.rbac ? `, authorize('admin')` : ''}, validate(registerSchema), handler.register);
+router.get('/:id', requireAuth${options.rbac ? `, authorize('admin')` : ''}, handler.show);
+router.put('/:id', requireAuth${options.rbac ? `, authorize('admin')` : ''}, handler.update);
+router.delete('/:id', requireAuth${options.rbac ? `, authorize('admin')` : ''}, handler.remove);
+
+export default router;
+`;
+    files['src/adapters/inbound/web/routes/index.ts'] = `import { Router } from 'express';
+import userRoutes from './user.routes.js';
+
+const router = Router();
+router.use('/users', userRoutes);
+
+export default router;
+`;
+    // 6. Application express setup and server start
+    let appMiddlewaresImport = '';
+    let appMiddlewares = '';
+    if (options.rateLimiting) {
+        appMiddlewaresImport += `import { apiLimiter } from './middlewares/rateLimit.middleware.js';\n`;
+        appMiddlewares += `app.use('/api', apiLimiter);\n`;
+    }
+    if (options.swagger) {
+        appMiddlewaresImport += `import swaggerUi from 'swagger-ui-express';\nimport { swaggerDocument } from './docs/swagger.js';\n`;
+        appMiddlewares += `
+app.use('/docs', swaggerUi.serve, swaggerUi.setup(swaggerDocument));
+`;
+        files['src/adapters/inbound/web/docs/swagger.ts'] = `const userSchema = {
+  type: "object",
+  properties: {
+    id: { type: "string" },
+    email: { type: "string" },
+    name: { type: "string", nullable: true },
+    role: { type: "string" },
+    createdAt: { type: "string", format: "date-time" }
+  }
+};
+
+const userInputSchema = {
+  type: "object",
+  properties: {
+    email: { type: "string" },
+    password: { type: "string" },
+    name: { type: "string" },
+    role: { type: "string", enum: ["user", "admin"] }
+  },
+  required: ["email"${options.auth ? ', "password"' : ''}]
+};
+
+export const swaggerDocument = {
+  openapi: "3.0.0",
+  info: { title: "${options.projectName} API (Hexagonal)", version: "1.0.0" },
+  servers: [{ url: "http://localhost:3000/api" }],
+  components: {
+    securitySchemes: {
+      bearerAuth: { type: "http", scheme: "bearer", bearerFormat: "JWT" }
+    },
+    schemas: {
+      User: userSchema,
+      UserInput: userInputSchema
+    }
+  },
+  paths: {
+    ${options.auth ? `"/users/register": {
+      post: {
+        summary: "Register",
+        requestBody: {
+          required: true,
+          content: { "application/json": { schema: userInputSchema } }
+        },
+        responses: { "201": { description: "Created" } }
+      }
+    },
+    "/users/login": {
+      post: {
+        summary: "Login",
+        requestBody: {
+          required: true,
+          content: { "application/json": { schema: { type: "object", properties: { email: { type: "string" }, password: { type: "string" } }, required: ["email", "password"] } } }
+        },
+        responses: { "200": { description: "Authenticated" } }
+      }
+    },
+    "/users/refresh": {
+      post: {
+        summary: "Refresh token",
+        requestBody: {
+          required: true,
+          content: { "application/json": { schema: { type: "object", properties: { refreshToken: { type: "string" } }, required: ["refreshToken"] } } }
+        },
+        responses: { "200": { description: "Token refreshed" } }
+      }
+    },` : ''}
+    "/users": {
+      get: {
+        summary: "List users",
+        ${options.auth ? 'security: [{ bearerAuth: [] }],' : ''}
+        responses: { "200": { description: "Users listed" } }
+      },
+      post: {
+        summary: "Create user",
+        ${options.auth ? 'description: "For authenticated scaffolds, use /users/register for signup semantics.",' : ''}
+        requestBody: {
+          required: true,
+          content: { "application/json": { schema: userInputSchema } }
+        },
+        responses: { "201": { description: "User created" } }
+      }
+    },
+    "/users/{id}": {
+      get: {
+        summary: "Get user by id",
+        ${options.auth ? 'security: [{ bearerAuth: [] }],' : ''}
+        parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+        responses: { "200": { description: "User found" }, "404": { description: "User not found" } }
+      },
+      put: {
+        summary: "Update user",
+        ${options.auth ? 'security: [{ bearerAuth: [] }],' : ''}
+        parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+        requestBody: { required: true, content: { "application/json": { schema: userInputSchema } } },
+        responses: { "200": { description: "User updated" } }
+      },
+      delete: {
+        summary: "Delete user",
+        ${options.auth ? 'security: [{ bearerAuth: [] }],' : ''}
+        parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+        responses: { "204": { description: "User deleted" } }
+      }
+    }
+  }
+};
+`;
+    }
+    files['src/adapters/inbound/web/express.server.ts'] = `import express from 'express';
+import cors from 'cors';
+import helmet from 'helmet';
+import routes from './routes/index.js';
+import { errorHandler } from './middlewares/error.middleware.js';
+${appMiddlewaresImport}
+const app = express();
+
+app.use(helmet());
+app.use(cors());
+app.use(express.json());
+
+${appMiddlewares}
+app.use('/api', routes);
+app.use(errorHandler);
+
+export default app;
+`;
+    let dbConnectionCode = '';
+    if (options.orm === 'mongoose') {
+        dbConnectionCode = `import mongoose from 'mongoose';
+async function connectDB() {
+  await mongoose.connect(env.DATABASE_URL);
+  console.log('🔌 Connected to MongoDB database successfully.');
+}`;
+    }
+    else if (options.orm === 'typeorm') {
+        dbConnectionCode = `import { AppDataSource } from './config/data-source.js';
+async function connectDB() {
+  await AppDataSource.initialize();
+  console.log('🔌 Connected to Database via TypeORM datasource.');
+}`;
+    }
+    else {
+        dbConnectionCode = `import { PrismaClient } from '@prisma/client';
+const prisma = new PrismaClient();
+async function connectDB() {
+  await prisma.$connect();
+  console.log('🔌 Connected to Database via Prisma client.');
+}`;
+    }
+    files['src/server.ts'] = `import app from './adapters/inbound/web/express.server.js';
+import { env } from './config/env.js';
+${dbConnectionCode}
+
+const PORT = env.PORT || 3000;
+
+async function start() {
+  try {
+    await connectDB();
+    app.listen(PORT, () => {
+      console.log(\`🚀 Server running on port \${PORT} (Hexagonal Ports & Adapters)\`);
+    });
+  } catch (err) {
+    console.error('❌ Failed to start application:', err);
+    process.exit(1);
+  }
+}
+start();
+`;
+    return files;
+}