create-flex-stack 1.0.0

package/dist/templates/cleanTemplate.js

@@ -0,0 +1,697 @@
+import { getTypeOrmConfig, getTypeOrmEntity } from './sharedTemplate.js';
+export function getCleanFiles(options) {
+    const files = {};
+    const userIdExpr = options.orm === 'prisma' ? 'user.id' : 'user._id.toString()';
+    // 1. Config & Env
+    files['src/infrastructure/config/env.config.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/infrastructure/database/connection.ts'] = getTypeOrmConfig(options)
+            .replace('../entities/user.entity.js', '../repositories/user.entity.js');
+    }
+    // 2. Domain Layer
+    files['src/domain/entities/user.entity.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. Application Layer
+    files['src/application/interfaces/user-repository.interface.ts'] = `import { User } from '../../domain/entities/user.entity.js';
+
+export interface IUserRepository {
+  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>;
+  findAll(): Promise<Omit<User, 'password' | 'refreshToken'>[]>;
+}
+`;
+    files['src/application/use-cases/register-user.use-case.ts'] = `import { IUserRepository } from '../interfaces/user-repository.interface.js';
+import { User } from '../../domain/entities/user.entity.js';
+
+export class RegisterUserUseCase {
+  constructor(
+    private userRepository: IUserRepository,
+    private passwordHasher: { hash(password: string): Promise<string> },
+    private tokenService: { generateTokens(payload: any): { accessToken: string; refreshToken: string } }
+  ) {}
+
+  async execute(input: any) {
+    const existing = await this.userRepository.findByEmail(input.email);
+    if (existing) throw new Error('Email already registered');
+
+    const hashedPassword = await this.passwordHasher.hash(input.password);
+    const user = await this.userRepository.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.userRepository.update(user.id, { refreshToken: tokens.refreshToken });
+
+    return {
+      user: { id: user.id, email: user.email, name: user.name, role: user.role },
+      ...tokens
+    };
+  }
+}
+`;
+    files['src/application/use-cases/login-user.use-case.ts'] = `import { IUserRepository } from '../interfaces/user-repository.interface.js';
+
+export class LoginUserUseCase {
+  constructor(
+    private userRepository: IUserRepository,
+    private passwordHasher: { compare(raw: string, hashed: string): Promise<boolean> },
+    private tokenService: { generateTokens(payload: any): { accessToken: string; refreshToken: string } }
+  ) {}
+
+  async execute(input: any) {
+    const user = await this.userRepository.findByEmail(input.email);
+    if (!user) throw new Error('Invalid email or password');
+
+    const isMatch = await this.passwordHasher.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.userRepository.update(user.id, { refreshToken: tokens.refreshToken });
+
+    return {
+      user: { id: user.id, email: user.email, name: user.name, role: user.role },
+      ...tokens
+    };
+  }
+}
+`;
+    files['src/application/use-cases/get-user-profile.use-case.ts'] = `import { IUserRepository } from '../interfaces/user-repository.interface.js';
+
+export class GetUserProfileUseCase {
+  constructor(private userRepository: IUserRepository) {}
+
+  async execute(userId: string) {
+    const user = await this.userRepository.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
+    };
+  }
+}
+`;
+    files['src/application/use-cases/refresh-token.use-case.ts'] = `import { IUserRepository } from '../interfaces/user-repository.interface.js';
+
+export class RefreshTokenUseCase {
+  constructor(
+    private userRepository: IUserRepository,
+    private tokenService: {
+      verifyRefreshToken(token: string): any;
+      generateTokens(payload: any): { accessToken: string; refreshToken: string };
+    }
+  ) {}
+
+  async execute(token: string) {
+    try {
+      const decoded = this.tokenService.verifyRefreshToken(token);
+      const user = await this.userRepository.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.userRepository.update(user.id, { refreshToken: tokens.refreshToken });
+      return tokens;
+    } catch (err) {
+      throw new Error('Invalid or expired refresh token');
+    }
+  }
+}
+`;
+    // 4. Presentation Layer
+    files['src/presentation/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/presentation/middlewares/auth.middleware.ts'] = `import { Request, Response, NextFunction } from 'express';
+import jwt from 'jsonwebtoken';
+import { env } from '../../infrastructure/config/env.config.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/presentation/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/presentation/middlewares/rateLimit.middleware.ts'] = `import rateLimit from 'express-rate-limit';
+
+export const apiLimiter = rateLimit({
+  windowMs: 15 * 60 * 1000,
+  max: 100,
+  standardHeaders: true,
+  legacyHeaders: false,
+  message: {
+    status: 'error',
+    statusCode: 429,
+    message: 'Too many requests, please try again later.'
+  }
+});
+`;
+    }
+    files['src/presentation/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/presentation/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/presentation/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);
+`;
+    }
+    // Presentation Controllers & Routes
+    const userRepoClass = options.orm === 'prisma' ? 'PrismaUserRepository' : options.orm === 'typeorm' ? 'TypeOrmUserRepository' : 'MongooseUserRepository';
+    const userRepoFile = options.orm === 'prisma' ? 'prisma-user.repository.impl.js' : options.orm === 'typeorm' ? 'typeorm-user.repository.impl.js' : 'mongoose-user.repository.impl.js';
+    files['src/presentation/controllers/user.controller.ts'] = `import { Request, Response, NextFunction } from 'express';
+import { RegisterUserUseCase } from '../../application/use-cases/register-user.use-case.js';
+import { LoginUserUseCase } from '../../application/use-cases/login-user.use-case.js';
+import { GetUserProfileUseCase } from '../../application/use-cases/get-user-profile.use-case.js';
+import { RefreshTokenUseCase } from '../../application/use-cases/refresh-token.use-case.js';
+import { ${userRepoClass} } from '../../infrastructure/repositories/${userRepoFile}';
+import { BcryptPasswordHasher } from '../../infrastructure/security/bcrypt.hasher.js';
+import { JwtTokenService } from '../../infrastructure/security/jwt.service.js';
+import { AuthenticatedRequest } from '../middlewares/auth.middleware.js';
+
+const userRepository = new ${userRepoClass}();
+const passwordHasher = new BcryptPasswordHasher();
+const tokenService = new JwtTokenService();
+
+export class UserController {
+  async register(req: Request, res: Response, next: NextFunction) {
+    try {
+      const useCase = new RegisterUserUseCase(userRepository, passwordHasher, 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(userRepository, passwordHasher, 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(userRepository, 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(userRepository);
+      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 userRepository.findAll();
+      res.status(200).json({ status: 'success', data: { users: list } });
+    } catch (err: any) {
+      next(err);
+    }
+  }
+}
+`;
+    files['src/presentation/routes/user.routes.ts'] = `import { Router } from 'express';
+import { UserController } from '../controllers/user.controller.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 controller = new UserController();
+
+router.post('/register', validate(registerSchema), controller.register);
+router.post('/login', validate(loginSchema), controller.login);
+router.post('/refresh', validate(refreshSchema), controller.refresh);
+router.get('/profile', requireAuth, controller.profile);
+router.get('/', requireAuth${options.rbac ? `, authorize('admin')` : ''}, controller.list);
+
+export default router;
+`;
+    files['src/presentation/routes/index.ts'] = `import { Router } from 'express';
+import userRoutes from './user.routes.js';
+
+const router = Router();
+router.use('/users', userRoutes);
+
+export default router;
+`;
+    // 5. Infrastructure Layer - Repositories impl
+    if (options.orm === 'prisma') {
+        files['src/infrastructure/repositories/prisma-user.repository.impl.ts'] = `import { PrismaClient } from '@prisma/client';
+import { IUserRepository } from '../../application/interfaces/user-repository.interface.js';
+import { User } from '../../domain/entities/user.entity.js';
+
+const prisma = new PrismaClient();
+
+export class PrismaUserRepository implements IUserRepository {
+  private mapToEntity(dbUser: any): User {
+    return new User(
+      dbUser.id,
+      dbUser.email,
+      dbUser.password,
+      dbUser.name,
+      dbUser.role,
+      dbUser.createdAt,
+      dbUser.refreshToken
+    );
+  }
+
+  async findByEmail(email: string): Promise<User | null> {
+    const user = await prisma.user.findUnique({ where: { email } });
+    return user ? this.mapToEntity(user) : null;
+  }
+  async findById(id: string): Promise<User | null> {
+    const user = await prisma.user.findUnique({ where: { id } });
+    return user ? this.mapToEntity(user) : null;
+  }
+  async create(user: Omit<User, 'id' | 'createdAt'>): Promise<User> {
+    const created = await prisma.user.create({ data: user });
+    return this.mapToEntity(created);
+  }
+  async update(id: string, user: Partial<User>): Promise<User> {
+    const updated = await prisma.user.update({ where: { id }, data: user });
+    return this.mapToEntity(updated);
+  }
+  async findAll(): Promise<Omit<User, 'password' | 'refreshToken'>[]> {
+    const list = await prisma.user.findMany();
+    return list.map(u => ({ id: u.id, email: u.email, name: u.name, role: u.role, createdAt: u.createdAt }));
+  }
+}
+`;
+    }
+    else if (options.orm === 'typeorm') {
+        files['src/infrastructure/repositories/user.entity.ts'] = getTypeOrmEntity();
+        files['src/infrastructure/repositories/typeorm-user.repository.impl.ts'] = `import { AppDataSource } from '../database/connection.js';
+import { UserEntity } from './user.entity.js';
+import { IUserRepository } from '../../application/interfaces/user-repository.interface.js';
+import { User } from '../../domain/entities/user.entity.js';
+
+export class TypeOrmUserRepository implements IUserRepository {
+  private repo = AppDataSource.getRepository(UserEntity);
+
+  private mapToEntity(u: UserEntity): 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 this.repo.findOne({ where: { email } });
+    return u ? this.mapToEntity(u) : null;
+  }
+  async findById(id: string): Promise<User | null> {
+    const u = await this.repo.findOne({ where: { id } });
+    return u ? this.mapToEntity(u) : null;
+  }
+  async create(user: Omit<User, 'id' | 'createdAt'>): Promise<User> {
+    const created = this.repo.create(user);
+    const saved = await this.repo.save(created);
+    return this.mapToEntity(saved);
+  }
+  async update(id: string, user: Partial<User>): Promise<User> {
+    await this.repo.update(id, user);
+    const updated = await this.findById(id);
+    return updated!;
+  }
+  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, role: u.role, createdAt: u.createdAt }));
+  }
+}
+`;
+    }
+    else {
+        // Mongoose
+        files['src/infrastructure/repositories/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);
+`;
+        files['src/infrastructure/repositories/mongoose-user.repository.impl.ts'] = `import { UserModel } from './user.model.js';
+import { IUserRepository } from '../../application/interfaces/user-repository.interface.js';
+import { User } from '../../domain/entities/user.entity.js';
+
+export class MongooseUserRepository implements IUserRepository {
+  private mapToEntity(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 user = await UserModel.findOne({ email });
+    return user ? this.mapToEntity(user) : null;
+  }
+  async findById(id: string): Promise<User | null> {
+    const user = await UserModel.findById(id);
+    return user ? this.mapToEntity(user) : null;
+  }
+  async create(user: Omit<User, 'id' | 'createdAt'>): Promise<User> {
+    const created = await UserModel.create(user);
+    return this.mapToEntity(created);
+  }
+  async update(id: string, user: Partial<User>): Promise<User> {
+    const updated = await UserModel.findByIdAndUpdate(id, { $set: user }, { new: true });
+    return this.mapToEntity(updated);
+  }
+  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 }));
+  }
+}
+`;
+    }
+    // Infrastructure Security
+    files['src/infrastructure/security/bcrypt.hasher.ts'] = `import bcrypt from 'bcryptjs';
+
+export class BcryptPasswordHasher {
+  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/infrastructure/security/jwt.service.ts'] = `import jwt from 'jsonwebtoken';
+import { env } from '../config/env.config.js';
+
+export class JwtTokenService {
+  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);
+  }
+}
+`;
+    // Shared types
+    files['src/shared/types/index.ts'] = `export type UserRole = 'user' | 'admin';`;
+    // 6. Presentation server/bootstrap
+    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';\n`;
+        appMiddlewares += `
+const swaggerDocument = {
+  openapi: "3.0.0",
+  info: { title: "${options.projectName} API (Clean)", version: "1.0.0" },
+  servers: [{ url: "http://localhost:3000/api" }],
+  paths: {
+    "/users/register": {
+      post: {
+        summary: "Register",
+        requestBody: {
+          required: true,
+          content: { "application/json": { schema: { type: "object", properties: { email: { type: "string" }, password: { type: "string" } } } } }
+        },
+        responses: { "201": { description: "Created" } }
+      }
+    }
+  }
+};
+app.use('/docs', swaggerUi.serve, swaggerUi.setup(swaggerDocument));
+`;
+    }
+    files['src/presentation/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 './infrastructure/database/connection.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 './presentation/express.server.js';
+import { env } from './infrastructure/config/env.config.js';
+${dbConnectionCode}
+
+const PORT = env.PORT || 3000;
+
+async function start() {
+  try {
+    await connectDB();
+    app.listen(PORT, () => {
+      console.log(\`🚀 Server running on port \${PORT} (Clean Architecture)\`);
+    });
+  } catch (err) {
+    console.error('❌ Failed to start application:', err);
+    process.exit(1);
+  }
+}
+start();
+`;
+    return files;
+}