create-flex-stack 1.0.0

package/dist/utils/generator.js

@@ -0,0 +1,1120 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { getTsConfig, getGitIgnore, getDockerFiles, getDotEnv, getReadme, getPackageJson, getRootPackageJson, getPrismaSchema, getMulterMiddleware, getJestConfig } from '../templates/sharedTemplate.js';
+import { getLayeredFiles } from '../templates/layeredTemplate.js';
+import { getVmcFiles } from '../templates/vmcTemplate.js';
+import { getModularFiles } from '../templates/modularTemplate.js';
+import { getCleanFiles } from '../templates/cleanTemplate.js';
+import { getHexagonalFiles } from '../templates/hexagonalTemplate.js';
+import { getFrontendFiles } from '../templates/frontendTemplate.js';
+export async function generateProject(options, onStep) {
+    const targetDir = path.resolve(process.cwd(), options.projectName);
+    if (fs.existsSync(targetDir)) {
+        throw new Error(`Directory "${options.projectName}" already exists.`);
+    }
+    onStep('Creating project directories...', 'start');
+    fs.mkdirSync(targetDir, { recursive: true });
+    const files = {};
+    if (options.frontend) {
+        // 1. MONOREPO STRUCTURE
+        files['package.json'] = getRootPackageJson(options.projectName);
+        files['.gitignore'] = getGitIgnore();
+        files['README.md'] = getReadme(options);
+        // Write Frontend files under frontend/
+        const frontFiles = getFrontendFiles(options);
+        for (const [relPath, content] of Object.entries(frontFiles)) {
+            files[`frontend/${relPath}`] = content;
+        }
+        // Write Backend files under backend/
+        files['backend/package.json'] = getPackageJson(options);
+        files['backend/tsconfig.json'] = getTsConfig(options);
+        files['backend/.gitignore'] = getGitIgnore();
+        files['backend/.env'] = getDotEnv(options);
+        files['backend/.env.example'] = getDotEnv(options);
+        files['backend/README.md'] = getReadme(options);
+        if (options.orm === 'prisma') {
+            files['backend/prisma/schema.prisma'] = getPrismaSchema(options);
+        }
+        if (options.docker) {
+            const { dockerfile, dockerCompose } = getDockerFiles(options);
+            files['backend/Dockerfile'] = dockerfile;
+            files['docker-compose.yml'] = dockerCompose; // Root compose
+        }
+        if (options.testing) {
+            files['backend/jest.config.json'] = getJestConfig();
+        }
+        // Backend Source
+        const srcFiles = getBackendSource(options);
+        for (const [relPath, content] of Object.entries(srcFiles)) {
+            files[`backend/${relPath}`] = content;
+        }
+    }
+    else {
+        // 2. SINGLE BACKEND ONLY STRUCTURE
+        files['package.json'] = getPackageJson(options);
+        files['tsconfig.json'] = getTsConfig(options);
+        files['.gitignore'] = getGitIgnore();
+        files['.env'] = getDotEnv(options);
+        files['.env.example'] = getDotEnv(options);
+        files['README.md'] = getReadme(options);
+        if (options.orm === 'prisma') {
+            files['prisma/schema.prisma'] = getPrismaSchema(options);
+        }
+        if (options.docker) {
+            const { dockerfile, dockerCompose } = getDockerFiles(options);
+            files['Dockerfile'] = dockerfile;
+            files['docker-compose.yml'] = dockerCompose;
+        }
+        if (options.testing) {
+            files['jest.config.json'] = getJestConfig();
+        }
+        // Backend Source
+        const srcFiles = getBackendSource(options);
+        for (const [relPath, content] of Object.entries(srcFiles)) {
+            files[relPath] = content;
+        }
+    }
+    // Write all files
+    for (const [relPath, content] of Object.entries(files)) {
+        const fullPath = path.join(targetDir, relPath);
+        const dir = path.dirname(fullPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(fullPath, content.trim() + '\n', 'utf8');
+    }
+    onStep('Directories and source code files generated.', 'stop');
+    // 3. Install dependencies
+    onStep('Installing project dependencies (this may take a few seconds)...', 'start');
+    try {
+        execSync('npm install', { cwd: targetDir, stdio: 'ignore' });
+        onStep('Dependencies installed successfully.', 'stop');
+    }
+    catch (err) {
+        onStep('Failed to install dependencies automatically. Run "npm install" manually.', 'error');
+    }
+    // 4. Run Prisma client generation if applicable
+    if (options.orm === 'prisma') {
+        onStep('Generating Prisma client...', 'start');
+        const prismaDir = options.frontend ? path.join(targetDir, 'backend') : targetDir;
+        try {
+            execSync('npx prisma generate', { cwd: prismaDir, stdio: 'ignore' });
+            onStep('Prisma client generated successfully.', 'stop');
+        }
+        catch (err) {
+            onStep('Failed to generate Prisma client automatically. Run "npx prisma generate" manually.', 'error');
+        }
+    }
+    // 5. Initialize Git repository
+    onStep('Initializing Git repository...', 'start');
+    try {
+        execSync('git init', { cwd: targetDir, stdio: 'ignore' });
+        execSync('git add .', { cwd: targetDir, stdio: 'ignore' });
+        execSync('git commit -m "Initial commit from create-flex-stack"', { cwd: targetDir, stdio: 'ignore' });
+        onStep('Git repository initialized and initial commit created.', 'stop');
+    }
+    catch (err) {
+        onStep('Failed to initialize Git repository automatically.', 'stop');
+    }
+}
+function getBackendSource(options) {
+    let srcFiles = {};
+    const sourceArchitecture = options.architecture;
+    if (sourceArchitecture === 'vmc') {
+        srcFiles = getVmcFiles(options);
+    }
+    else if (sourceArchitecture === 'modular') {
+        srcFiles = getModularFiles(options);
+    }
+    else if (sourceArchitecture === 'clean') {
+        srcFiles = getCleanFiles(options);
+    }
+    else if (sourceArchitecture === 'hexagonal') {
+        srcFiles = getHexagonalFiles(options);
+    }
+    else {
+        srcFiles = getLayeredFiles(options);
+    }
+    if (!options.auth) {
+        srcFiles = applyNoAuthBackend(options, srcFiles);
+    }
+    // Dynamically inject File Upload middleware if toggled on
+    if (options.fileUpload) {
+        const uploadMiddlewareContent = getMulterMiddleware();
+        if (sourceArchitecture === 'clean') {
+            srcFiles['src/presentation/middlewares/upload.middleware.ts'] = uploadMiddlewareContent.replace('./errorHandler.js', './error.middleware.js');
+        }
+        else if (sourceArchitecture === 'hexagonal') {
+            srcFiles['src/adapters/inbound/web/middlewares/upload.middleware.ts'] = uploadMiddlewareContent.replace('./errorHandler.js', './error.middleware.js');
+        }
+        else {
+            srcFiles['src/middlewares/upload.ts'] = uploadMiddlewareContent;
+        }
+    }
+    if (options.testing) {
+        srcFiles['tests/health.test.ts'] = `describe('project scaffold', () => {
+  it('has a working test setup', () => {
+    expect(true).toBe(true);
+  });
+});
+`;
+    }
+    return srcFiles;
+}
+function applyNoAuthBackend(options, srcFiles) {
+    const files = { ...srcFiles };
+    for (const key of Object.keys(files)) {
+        if (key.includes('/auth') ||
+            key.includes('/rbac') ||
+            key.includes('/security/') ||
+            key.includes('password-hasher') ||
+            key.includes('token-service') ||
+            key.includes('login-user') ||
+            key.includes('register-user') ||
+            key.includes('refresh-token') ||
+            key.includes('auth.service') ||
+            key.includes('auth.use-cases')) {
+            delete files[key];
+        }
+    }
+    if (options.architecture === 'vmc') {
+        addPublicLayeredLikeUsers(files, {
+            schemaPath: 'src/view/user.view.ts',
+            servicePath: 'src/model/user.model-service.ts',
+            controllerPath: 'src/controller/user.controller.ts',
+            routesPath: 'src/routes/user.routes.ts',
+            repositoryImport: '../model/user.repository.js',
+            serviceImport: '../model/user.model-service.js',
+            controllerImport: '../controller/user.controller.js',
+            schemaImport: '../view/user.view.js',
+            errorImport: '../middlewares/errorHandler.js',
+            repositoryPath: 'src/model/user.repository.ts',
+            repositoryClass: 'UserRepository',
+        });
+    }
+    else if (options.architecture === 'modular') {
+        addPublicLayeredLikeUsers(files, {
+            schemaPath: 'src/modules/users/users.dto.ts',
+            servicePath: 'src/modules/users/users.service.ts',
+            controllerPath: 'src/modules/users/users.controller.ts',
+            routesPath: 'src/modules/users/users.routes.ts',
+            repositoryPath: 'src/modules/users/users.repository.ts',
+            repositoryImport: './users.repository.js',
+            serviceImport: './users.service.js',
+            controllerImport: './users.controller.js',
+            schemaImport: './users.dto.js',
+            errorImport: '../../middlewares/errorHandler.js',
+            repositoryClass: 'UsersRepository',
+        });
+    }
+    else if (options.architecture === 'layered') {
+        addPublicLayeredLikeUsers(files, {
+            schemaPath: 'src/schemas/user.schema.ts',
+            servicePath: 'src/services/user.service.ts',
+            controllerPath: 'src/controllers/user.controller.ts',
+            routesPath: 'src/routes/user.routes.ts',
+            repositoryPath: 'src/repositories/user.repository.ts',
+            repositoryImport: '../repositories/user.repository.js',
+            serviceImport: '../services/user.service.js',
+            controllerImport: '../controllers/user.controller.js',
+            schemaImport: '../schemas/user.schema.js',
+            errorImport: '../middlewares/errorHandler.js',
+            repositoryClass: 'UserRepository',
+        });
+    }
+    else if (options.architecture === 'clean') {
+        addPublicCleanUsers(files, options);
+    }
+    else if (options.architecture === 'hexagonal') {
+        addPublicHexagonalUsers(files, options);
+    }
+    if (options.swagger) {
+        addPublicSwagger(files, options.architecture);
+    }
+    return files;
+}
+function addPublicSwagger(files, architecture) {
+    const swagger = `export const swaggerDocument = {
+  openapi: "3.0.0",
+  info: { title: "API Documentation", version: "1.0.0" },
+  paths: {
+    "/health": {
+      get: {
+        summary: "Health check",
+        responses: { "200": { description: "API is running" } }
+      }
+    },
+    "/users": {
+      get: {
+        summary: "List users",
+        responses: { "200": { description: "Users returned" } }
+      },
+      post: {
+        summary: "Create user",
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                required: ["email"],
+                properties: {
+                  email: { type: "string", format: "email" },
+                  name: { type: "string" },
+                  role: { type: "string", enum: ["user", "admin"] }
+                }
+              }
+            }
+          }
+        },
+        responses: { "201": { description: "User created" } }
+      }
+    },
+    "/users/{id}": {
+      get: {
+        summary: "Get user",
+        parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+        responses: { "200": { description: "User returned" }, "404": { description: "User not found" } }
+      },
+      put: {
+        summary: "Update user",
+        parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  email: { type: "string", format: "email" },
+                  name: { type: "string" },
+                  role: { type: "string", enum: ["user", "admin"] }
+                }
+              }
+            }
+          }
+        },
+        responses: { "200": { description: "User updated" } }
+      },
+      delete: {
+        summary: "Delete user",
+        parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+        responses: { "204": { description: "User deleted" } }
+      }
+    }
+  }
+};
+`;
+    if (architecture === 'hexagonal') {
+        files['src/adapters/inbound/web/docs/swagger.ts'] = swagger;
+        return;
+    }
+    const serverPath = architecture === 'clean' ? 'src/presentation/express.server.ts' : 'src/app.ts';
+    const server = files[serverPath];
+    if (!server)
+        return;
+    files[serverPath] = server.replace(/const swaggerDocument = [\s\S]*?app\.use\('\/docs', swaggerUi\.serve, swaggerUi\.setup\(swaggerDocument\)\);/, `${swagger.replace('export const', 'const')}\napp.use('/docs', swaggerUi.serve, swaggerUi.setup(swaggerDocument));`);
+}
+function addPublicHexagonalUsers(files, options) {
+    files['src/domain/models/user.model.ts'] = `export class User {
+  constructor(
+    public readonly id: string,
+    public readonly email: string,
+    public readonly name: string | null,
+    public readonly role: string | null,
+    public readonly createdAt: Date
+  ) {}
+}
+`;
+    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<User[]>;
+}
+`;
+    files['src/ports/inbound/user-usecase.port.ts'] = `export interface ICreateUserPort {
+  execute(input: { email: string; name?: string; role?: string }): Promise<any>;
+}
+
+export interface IListUsersPort {
+  execute(): Promise<any[]>;
+}
+
+export interface IGetUserPort {
+  execute(userId: string): Promise<any>;
+}
+
+export interface IUpdateUserPort {
+  execute(userId: string, input: { email?: string; name?: string; role?: string }): Promise<any>;
+}
+
+export interface IDeleteUserPort {
+  execute(userId: string): Promise<void>;
+}
+`;
+    files['src/application/use-cases/user.use-cases.ts'] = `import { IUserRepositoryPort } from '../../ports/outbound/user-repository.port.js';
+import { ICreateUserPort, IDeleteUserPort, IGetUserPort, IListUsersPort, IUpdateUserPort } from '../../ports/inbound/user-usecase.port.js';
+
+export class CreateUserUseCase implements ICreateUserPort {
+  constructor(private userRepo: IUserRepositoryPort) {}
+
+  async execute(input: { email: string; name?: string; role?: string }) {
+    const existing = await this.userRepo.findByEmail(input.email);
+    if (existing) {
+      throw new Error('Email already exists');
+    }
+
+    const user = await this.userRepo.create({
+      email: input.email,
+      name: input.name || null,
+      role: input.role || null,
+    });
+
+    return user;
+  }
+}
+
+export class ListUsersUseCase implements IListUsersPort {
+  constructor(private userRepo: IUserRepositoryPort) {}
+
+  execute() {
+    return this.userRepo.findAll();
+  }
+}
+
+export class GetUserUseCase implements IGetUserPort {
+  constructor(private userRepo: IUserRepositoryPort) {}
+
+  async execute(userId: string) {
+    const user = await this.userRepo.findById(userId);
+    if (!user) {
+      throw new Error('User not found');
+    }
+
+    return user;
+  }
+}
+
+export class UpdateUserUseCase implements IUpdateUserPort {
+  constructor(private userRepo: IUserRepositoryPort) {}
+
+  execute(userId: string, input: { email?: string; name?: string; role?: string }) {
+    return this.userRepo.update(userId, input);
+  }
+}
+
+export class DeleteUserUseCase implements IDeleteUserPort {
+  constructor(private userRepo: IUserRepositoryPort) {}
+
+  execute(userId: string) {
+    return this.userRepo.delete(userId);
+  }
+}
+`;
+    files['src/adapters/inbound/web/schemas/user.schema.ts'] = `import { z } from 'zod';
+
+export const createUserSchema = z.object({
+  body: z.object({
+    email: z.string().email(),
+    name: z.string().min(2).optional(),
+    role: z.enum(['user', 'admin']).optional(),
+  }),
+});
+`;
+    files['src/adapters/inbound/web/handlers/user.handler.ts'] = `import { Request, Response, NextFunction } from 'express';
+import { CreateUserUseCase, DeleteUserUseCase, GetUserUseCase, ListUsersUseCase, UpdateUserUseCase } from '../../../../application/use-cases/user.use-cases.js';
+import { OrmUserRepository } from '../../../outbound/db/orm-user.repository.js';
+
+const userRepo = new OrmUserRepository();
+
+export class UserHandler {
+  async create(req: Request, res: Response, next: NextFunction) {
+    try {
+      const useCase = new CreateUserUseCase(userRepo);
+      const user = await useCase.execute(req.body);
+      res.status(201).json({ status: 'success', data: { user } });
+    } catch (err: any) {
+      res.status(400).json({ status: 'error', statusCode: 400, message: err.message });
+    }
+  }
+
+  async show(req: Request, res: Response, next: NextFunction) {
+    try {
+      const useCase = new GetUserUseCase(userRepo);
+      const user = await useCase.execute(req.params.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 useCase = new ListUsersUseCase(userRepo);
+      const users = await useCase.execute();
+      res.status(200).json({ status: 'success', data: { users } });
+    } catch (err: any) {
+      next(err);
+    }
+  }
+
+  async update(req: Request, res: Response, next: NextFunction) {
+    try {
+      const useCase = new UpdateUserUseCase(userRepo);
+      const user = await useCase.execute(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 {
+      const useCase = new DeleteUserUseCase(userRepo);
+      await useCase.execute(req.params.id);
+      res.status(204).send();
+    } catch (err: any) {
+      next(err);
+    }
+  }
+}
+`;
+    files['src/adapters/inbound/web/routes/user.routes.ts'] = `import { Router } from 'express';
+import { UserHandler } from '../handlers/user.handler.js';
+import { validate } from '../middlewares/validate.middleware.js';
+import { createUserSchema } from '../schemas/user.schema.js';
+
+const router = Router();
+const handler = new UserHandler();
+
+router.get('/', handler.list);
+router.get('/:id', handler.show);
+router.post('/', validate(createUserSchema), handler.create);
+router.put('/:id', handler.update);
+router.delete('/:id', handler.remove);
+
+export default router;
+`;
+    if (options.orm === 'typeorm') {
+        files['src/adapters/outbound/db/user.entity.ts'] = `import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn } from "typeorm";
+
+@Entity({ name: "users" })
+export class UserEntity {
+  @PrimaryGeneratedColumn("uuid")
+  id!: string;
+
+  @Column({ unique: true })
+  email!: string;
+
+  @Column({ nullable: true })
+  name?: string;
+
+  @Column({ nullable: true })
+  role?: string;
+
+  @CreateDateColumn()
+  createdAt!: Date;
+
+  @UpdateDateColumn()
+  updatedAt!: Date;
+}
+`;
+        files['src/adapters/outbound/db/orm-user.repository.ts'] = `import { AppDataSource } from '../../../config/data-source.js';
+import { UserEntity } from './user.entity.js';
+import { User } from '../../../domain/models/user.model.js';
+import { IUserRepositoryPort } from '../../../ports/outbound/user-repository.port.js';
+
+export class OrmUserRepository implements IUserRepositoryPort {
+  private repo = AppDataSource.getRepository(UserEntity);
+
+  private mapToModel(u: UserEntity): User {
+    return new User(u.id, u.email, u.name ?? null, u.role ?? null, u.createdAt);
+  }
+
+  async findByEmail(email: string): Promise<User | null> {
+    const user = await this.repo.findOne({ where: { email } });
+    return user ? this.mapToModel(user) : null;
+  }
+
+  async findById(id: string): Promise<User | null> {
+    const user = await this.repo.findOne({ where: { id } });
+    return user ? this.mapToModel(user) : null;
+  }
+
+  async create(user: Omit<User, 'id' | 'createdAt'>): Promise<User> {
+    const created = this.repo.create({ ...user, name: user.name ?? undefined, role: user.role ?? 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, { ...user, name: user.name ?? undefined, role: user.role ?? undefined });
+    const updated = await this.repo.findOneByOrFail({ id });
+    return this.mapToModel(updated);
+  }
+
+  async delete(id: string): Promise<void> {
+    await this.repo.delete(id);
+  }
+
+  async findAll(): Promise<User[]> {
+    const users = await this.repo.find();
+    return users.map((user: UserEntity) => this.mapToModel(user));
+  }
+}
+`;
+        return;
+    }
+    files['src/adapters/outbound/db/orm-user.repository.ts'] = `import { PrismaClient } from '@prisma/client';
+import { User } from '../../../domain/models/user.model.js';
+import { IUserRepositoryPort } from '../../../ports/outbound/user-repository.port.js';
+
+const prisma = new PrismaClient();
+
+export class OrmUserRepository implements IUserRepositoryPort {
+  private mapToModel(u: any): User {
+    return new User(u.id, u.email, u.name, u.role, u.createdAt);
+  }
+
+  async findByEmail(email: string): Promise<User | null> {
+    const user = await prisma.user.findUnique({ where: { email } });
+    return user ? this.mapToModel(user) : null;
+  }
+
+  async findById(id: string): Promise<User | null> {
+    const user = await prisma.user.findUnique({ where: { id } });
+    return user ? this.mapToModel(user) : 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<User[]> {
+    const users = await prisma.user.findMany();
+    return users.map(user => this.mapToModel(user));
+  }
+}
+`;
+}
+function addPublicCleanUsers(files, options) {
+    const repoImport = options.orm === 'typeorm'
+        ? '../../infrastructure/repositories/typeorm-user.repository.impl.js'
+        : options.orm === 'mongoose'
+            ? '../../infrastructure/repositories/mongoose-user.repository.impl.js'
+            : '../../infrastructure/repositories/prisma-user.repository.impl.js';
+    const repoClass = options.orm === 'typeorm'
+        ? 'TypeOrmUserRepository'
+        : options.orm === 'mongoose'
+            ? 'MongooseUserRepository'
+            : 'PrismaUserRepository';
+    files['src/domain/entities/user.entity.ts'] = `export class User {
+  constructor(
+    public readonly id: string,
+    public readonly email: string,
+    public readonly name: string | null,
+    public readonly role: string | null,
+    public readonly createdAt: Date
+  ) {}
+}
+`;
+    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>;
+  delete(id: string): Promise<void>;
+  findAll(): Promise<User[]>;
+}
+`;
+    files['src/application/use-cases/user.use-cases.ts'] = `import { IUserRepository } from '../interfaces/user-repository.interface.js';
+
+export class CreateUserUseCase {
+  constructor(private userRepository: IUserRepository) {}
+
+  async execute(input: { email: string; name?: string; role?: string }) {
+    const existing = await this.userRepository.findByEmail(input.email);
+    if (existing) {
+      throw new Error('Email already exists');
+    }
+
+    return this.userRepository.create({
+      email: input.email,
+      name: input.name || null,
+      role: input.role || null,
+    });
+  }
+}
+
+export class ListUsersUseCase {
+  constructor(private userRepository: IUserRepository) {}
+
+  execute() {
+    return this.userRepository.findAll();
+  }
+}
+
+export class GetUserUseCase {
+  constructor(private userRepository: IUserRepository) {}
+
+  async execute(id: string) {
+    const user = await this.userRepository.findById(id);
+    if (!user) {
+      throw new Error('User not found');
+    }
+
+    return user;
+  }
+}
+
+export class UpdateUserUseCase {
+  constructor(private userRepository: IUserRepository) {}
+
+  execute(id: string, input: { email?: string; name?: string; role?: string }) {
+    return this.userRepository.update(id, input);
+  }
+}
+
+export class DeleteUserUseCase {
+  constructor(private userRepository: IUserRepository) {}
+
+  execute(id: string) {
+    return this.userRepository.delete(id);
+  }
+}
+`;
+    files['src/presentation/schemas/user.schema.ts'] = `import { z } from 'zod';
+
+export const createUserSchema = z.object({
+  body: z.object({
+    email: z.string().email(),
+    name: z.string().min(2).optional(),
+    role: z.enum(['user', 'admin']).optional(),
+  }),
+});
+`;
+    files['src/presentation/controllers/user.controller.ts'] = `import { Request, Response, NextFunction } from 'express';
+import { CreateUserUseCase, DeleteUserUseCase, GetUserUseCase, ListUsersUseCase, UpdateUserUseCase } from '../../application/use-cases/user.use-cases.js';
+import { ${repoClass} } from '${repoImport}';
+
+const userRepository = new ${repoClass}();
+
+export class UserController {
+  async create(req: Request, res: Response, next: NextFunction) {
+    try {
+      const useCase = new CreateUserUseCase(userRepository);
+      const user = await useCase.execute(req.body);
+      res.status(201).json({ status: 'success', data: { user } });
+    } catch (err: any) {
+      res.status(400).json({ status: 'error', statusCode: 400, message: err.message });
+    }
+  }
+
+  async show(req: Request, res: Response, next: NextFunction) {
+    try {
+      const useCase = new GetUserUseCase(userRepository);
+      const user = await useCase.execute(req.params.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 useCase = new ListUsersUseCase(userRepository);
+      const users = await useCase.execute();
+      res.status(200).json({ status: 'success', data: { users } });
+    } catch (err) {
+      next(err);
+    }
+  }
+
+  async update(req: Request, res: Response, next: NextFunction) {
+    try {
+      const useCase = new UpdateUserUseCase(userRepository);
+      const user = await useCase.execute(req.params.id, req.body);
+      res.status(200).json({ status: 'success', data: { user } });
+    } catch (err) {
+      next(err);
+    }
+  }
+
+  async remove(req: Request, res: Response, next: NextFunction) {
+    try {
+      const useCase = new DeleteUserUseCase(userRepository);
+      await useCase.execute(req.params.id);
+      res.status(204).send();
+    } catch (err) {
+      next(err);
+    }
+  }
+}
+`;
+    files['src/presentation/routes/user.routes.ts'] = `import { Router } from 'express';
+import { UserController } from '../controllers/user.controller.js';
+import { validate } from '../middlewares/validate.middleware.js';
+import { createUserSchema } from '../schemas/user.schema.js';
+
+const router = Router();
+const controller = new UserController();
+
+router.get('/', controller.list);
+router.get('/:id', controller.show);
+router.post('/', validate(createUserSchema), controller.create);
+router.put('/:id', controller.update);
+router.delete('/:id', controller.remove);
+
+export default router;
+`;
+    addPublicCleanRepository(files, options);
+}
+function addPublicCleanRepository(files, options) {
+    const orm = options.orm;
+    if (orm === 'typeorm') {
+        const type = options.database === 'mysql' ? 'mysql' : options.database === 'sqlite' ? 'sqlite' : 'postgres';
+        const databaseLine = type === 'sqlite' ? '  database: "dev.db",' : '  url: process.env.DATABASE_URL,';
+        files['src/infrastructure/database/connection.ts'] = `import "reflect-metadata";
+import { DataSource } from "typeorm";
+import { UserEntity } from "../repositories/user.entity.js";
+
+export const AppDataSource = new DataSource({
+  type: "${type}",
+${databaseLine}
+  synchronize: true,
+  logging: false,
+  entities: [UserEntity],
+});
+`;
+        files['src/infrastructure/repositories/user.entity.ts'] = `import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn } from "typeorm";
+
+@Entity({ name: "users" })
+export class UserEntity {
+  @PrimaryGeneratedColumn("uuid")
+  id!: string;
+
+  @Column({ unique: true })
+  email!: string;
+
+  @Column({ nullable: true })
+  name?: string;
+
+  @Column({ nullable: true })
+  role?: string;
+
+  @CreateDateColumn()
+  createdAt!: Date;
+
+  @UpdateDateColumn()
+  updatedAt!: Date;
+}
+`;
+        files['src/infrastructure/repositories/typeorm-user.repository.impl.ts'] = `import { AppDataSource } from '../database/connection.js';
+import { UserEntity } from './user.entity.js';
+import { User } from '../../domain/entities/user.entity.js';
+import { IUserRepository } from '../../application/interfaces/user-repository.interface.js';
+
+export class TypeOrmUserRepository implements IUserRepository {
+  private repo = AppDataSource.getRepository(UserEntity);
+
+  private mapToEntity(u: UserEntity): User {
+    return new User(u.id, u.email, u.name ?? null, u.role ?? null, u.createdAt);
+  }
+
+  async findByEmail(email: string): Promise<User | null> {
+    const user = await this.repo.findOne({ where: { email } });
+    return user ? this.mapToEntity(user) : null;
+  }
+
+  async findById(id: string): Promise<User | null> {
+    const user = await this.repo.findOne({ where: { id } });
+    return user ? this.mapToEntity(user) : null;
+  }
+
+  async create(user: Omit<User, 'id' | 'createdAt'>): Promise<User> {
+    const created = this.repo.create({ ...user, name: user.name ?? undefined, role: user.role ?? undefined });
+    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, name: user.name ?? undefined, role: user.role ?? undefined });
+    const updated = await this.repo.findOneByOrFail({ id });
+    return this.mapToEntity(updated);
+  }
+
+  async delete(id: string): Promise<void> {
+    await this.repo.delete(id);
+  }
+
+  async findAll(): Promise<User[]> {
+    const users = await this.repo.find();
+    return users.map((user: UserEntity) => this.mapToEntity(user));
+  }
+}
+`;
+        return;
+    }
+    if (orm === 'mongoose') {
+        files['src/infrastructure/repositories/mongoose-user.repository.impl.ts'] = `import { UserModel } from '../models/user.model.js';
+import { User } from '../../domain/entities/user.entity.js';
+import { IUserRepository } from '../../application/interfaces/user-repository.interface.js';
+
+export class MongooseUserRepository implements IUserRepository {
+  private mapToEntity(doc: any): User {
+    return new User(doc._id.toString(), doc.email, doc.name ?? null, doc.role ?? null, doc.createdAt);
+  }
+
+  async findByEmail(email: string): Promise<User | null> {
+    const doc = await UserModel.findOne({ email });
+    return doc ? this.mapToEntity(doc) : null;
+  }
+
+  async findById(id: string): Promise<User | null> {
+    const doc = await UserModel.findById(id);
+    return doc ? this.mapToEntity(doc) : null;
+  }
+
+  async create(user: Omit<User, 'id' | 'createdAt'>): Promise<User> {
+    const doc = await UserModel.create(user);
+    return this.mapToEntity(doc);
+  }
+
+  async update(id: string, user: Partial<User>): Promise<User> {
+    const doc = await UserModel.findByIdAndUpdate(id, user, { new: true });
+    if (!doc) throw new Error('User not found');
+    return this.mapToEntity(doc);
+  }
+
+  async delete(id: string): Promise<void> {
+    await UserModel.findByIdAndDelete(id);
+  }
+
+  async findAll(): Promise<User[]> {
+    const docs = await UserModel.find();
+    return docs.map(doc => this.mapToEntity(doc));
+  }
+}
+`;
+        return;
+    }
+    files['src/infrastructure/repositories/prisma-user.repository.impl.ts'] = `import { PrismaClient } from '@prisma/client';
+import { User } from '../../domain/entities/user.entity.js';
+import { IUserRepository } from '../../application/interfaces/user-repository.interface.js';
+
+const prisma = new PrismaClient();
+
+export class PrismaUserRepository implements IUserRepository {
+  private mapToEntity(dbUser: any): User {
+    return new User(dbUser.id, dbUser.email, dbUser.name, dbUser.role, dbUser.createdAt);
+  }
+
+  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 delete(id: string): Promise<void> {
+    await prisma.user.delete({ where: { id } });
+  }
+
+  async findAll(): Promise<User[]> {
+    const users = await prisma.user.findMany();
+    return users.map(user => this.mapToEntity(user));
+  }
+}
+`;
+}
+function addPublicLayeredLikeUsers(files, paths) {
+    files[paths.repositoryPath] = `import { PrismaClient } from '@prisma/client';
+
+const prisma = new PrismaClient();
+
+export class ${paths.repositoryClass} {
+  async findByEmail(email: string) {
+    return prisma.user.findUnique({ where: { email } });
+  }
+
+  async findById(id: string) {
+    return prisma.user.findUnique({ where: { id } });
+  }
+
+  async create(data: { email: string; name?: string | null; role?: string | null }) {
+    return prisma.user.create({ data });
+  }
+
+  async update(id: string, data: { email?: string; name?: string | null; role?: string | null }) {
+    return prisma.user.update({ where: { id }, data });
+  }
+
+  async delete(id: string) {
+    return prisma.user.delete({ where: { id } });
+  }
+
+  async findAll() {
+    return prisma.user.findMany();
+  }
+}
+`;
+    files[paths.schemaPath] = `import { z } from 'zod';
+
+export const createUserSchema = z.object({
+  body: z.object({
+    email: z.string().email('Invalid email address'),
+    name: z.string().min(2, 'Name must be at least 2 characters').optional(),
+    role: z.enum(['user', 'admin']).optional(),
+  }),
+});
+`;
+    files[paths.servicePath] = `import { ${paths.repositoryClass} } from '${paths.repositoryImport}';
+import { AppError } from '${paths.errorImport}';
+
+const userRepository = new ${paths.repositoryClass}();
+
+export class UserService {
+  async create(data: any) {
+    const existing = await userRepository.findByEmail(data.email);
+    if (existing) {
+      throw new AppError(400, 'Email already exists');
+    }
+
+    const user = await userRepository.create(data);
+    return {
+      id: user.id,
+      email: user.email,
+      name: user.name,
+      role: user.role,
+      createdAt: user.createdAt,
+    };
+  }
+
+  async getById(id: string) {
+    const user = await userRepository.findById(id);
+    if (!user) {
+      throw new AppError(404, 'User not found');
+    }
+
+    return {
+      id: user.id,
+      email: user.email,
+      name: user.name,
+      role: user.role,
+      createdAt: user.createdAt,
+    };
+  }
+
+  async getAllUsers() {
+    return userRepository.findAll();
+  }
+
+  async update(id: string, data: any) {
+    return userRepository.update(id, data);
+  }
+
+  async remove(id: string) {
+    await userRepository.delete(id);
+  }
+}
+`;
+    files[paths.controllerPath] = `import { Request, Response, NextFunction } from 'express';
+import { UserService } from '${paths.serviceImport}';
+
+const userService = new UserService();
+
+export class UserController {
+  async create(req: Request, res: Response, next: NextFunction) {
+    try {
+      const user = await userService.create(req.body);
+      res.status(201).json({ status: 'success', data: { user } });
+    } catch (err) {
+      next(err);
+    }
+  }
+
+  async show(req: Request, res: Response, next: NextFunction) {
+    try {
+      const user = await userService.getById(req.params.id);
+      res.status(200).json({ status: 'success', data: { user } });
+    } catch (err) {
+      next(err);
+    }
+  }
+
+  async list(req: Request, res: Response, next: NextFunction) {
+    try {
+      const users = await userService.getAllUsers();
+      res.status(200).json({ status: 'success', data: { users } });
+    } catch (err) {
+      next(err);
+    }
+  }
+
+  async update(req: Request, res: Response, next: NextFunction) {
+    try {
+      const user = await userService.update(req.params.id, req.body);
+      res.status(200).json({ status: 'success', data: { user } });
+    } catch (err) {
+      next(err);
+    }
+  }
+
+  async remove(req: Request, res: Response, next: NextFunction) {
+    try {
+      await userService.remove(req.params.id);
+      res.status(204).send();
+    } catch (err) {
+      next(err);
+    }
+  }
+}
+`;
+    files[paths.routesPath] = `import { Router } from 'express';
+import { UserController } from '${paths.controllerImport}';
+import { validate } from '${paths.routesPath.includes('/modules/') ? '../../middlewares/validate.js' : '../middlewares/validate.js'}';
+import { createUserSchema } from '${paths.schemaImport}';
+
+const router = Router();
+const controller = new UserController();
+
+router.get('/', controller.list);
+router.get('/:id', controller.show);
+router.post('/', validate(createUserSchema), controller.create);
+router.put('/:id', controller.update);
+router.delete('/:id', controller.remove);
+
+export default router;
+`;
+}