archforge-x 1.0.2 → 1.0.4

package/dist/generators/node/express.js

@@ -0,0 +1,920 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressGenerator = void 0;
+const base_1 = require("../base");
+class ExpressGenerator extends base_1.BaseGenerator {
+    getGeneratorName() {
+        return "Express.js";
+    }
+    async generateProjectStructure(root, arch, options) {
+        const archStyle = options.architecture || "clean";
+        // 1. Common Configuration Files
+        this.generateCommonFiles(root, options);
+        // 2. Source Code Structure based on Architecture
+        if (archStyle === "clean") {
+            this.generateCleanArchitecture(root, options);
+        }
+        else if (archStyle === "mvc") {
+            this.generateMVCArchitecture(root, options);
+        }
+        else {
+            this.generateLayeredArchitecture(root, options);
+        }
+    }
+    generateCommonFiles(root, options) {
+        const projectName = options.projectName || "express-app";
+        // package.json
+        this.writeFile(root, "package.json", JSON.stringify({
+            name: projectName,
+            version: "1.0.0",
+            description: "Generated by ArchForge X",
+            main: "dist/main.js",
+            scripts: {
+                "start": "node dist/main.js",
+                "start:dev": "ts-node-dev --respawn --transpile-only src/main.ts",
+                "build": "tsc",
+                "lint": "eslint . --ext .ts",
+                "test": "jest"
+            },
+            dependencies: {
+                "express": "^4.18.2",
+                "express-async-errors": "^3.1.1",
+                "cors": "^2.8.5",
+                "dotenv": "^16.3.1",
+                "helmet": "^7.0.0",
+                "morgan": "^1.10.0",
+                "winston": "^3.10.0",
+                "uuid": "^9.0.0",
+                "zod": "^3.22.2",
+                "ioredis": "^5.3.2",
+                "http-status-codes": "^2.2.0",
+                ...(options.orm === "prisma" ? { "@prisma/client": "^5.0.0" } : {}),
+                ...(options.orm === "typeorm" ? { "typeorm": "^0.3.17", "reflect-metadata": "^0.1.13" } : {})
+            },
+            devDependencies: {
+                "@types/express": "^4.17.17",
+                "@types/cors": "^2.8.13",
+                "@types/node": "^20.4.5",
+                "@types/morgan": "^1.10.0",
+                "@types/uuid": "^9.0.2",
+                "typescript": "^5.1.6",
+                "ts-node-dev": "^2.0.0",
+                "eslint": "^8.45.0",
+                "eslint-plugin-import": "^2.27.5",
+                "jest": "^29.6.1",
+                "ts-jest": "^29.1.1",
+                "@types/jest": "^29.5.3",
+                "pino-pretty": "^10.2.0",
+                ...(options.orm === "prisma" ? { "prisma": "^5.0.0" } : {})
+            }
+        }, null, 2));
+        // Prisma Schema
+        if (options.orm === "prisma") {
+            this.generatePrismaSchema(root, options);
+        }
+        // ... (tsconfig.json and .eslintrc.json remain same)
+        // Logger Configuration
+        this.writeFile(root, "src/infrastructure/logger.ts", `
+import winston from "winston";
+
+const logger = winston.createLogger({
+    level: process.env.LOG_LEVEL || "info",
+    format: winston.format.combine(
+        winston.format.timestamp(),
+        winston.format.json()
+    ),
+    transports: [
+        new winston.transports.Console({
+            format: winston.format.combine(
+                winston.format.colorize(),
+                winston.format.simple()
+            )
+        })
+    ]
+});
+
+export default logger;
+        `);
+        // tsconfig.json
+        this.writeFile(root, "tsconfig.json", JSON.stringify({
+            compilerOptions: {
+                target: "ES2020",
+                module: "commonjs",
+                outDir: "./dist",
+                rootDir: "./src",
+                strict: true,
+                esModuleInterop: true,
+                skipLibCheck: true,
+                forceConsistentCasingInFileNames: true
+            },
+            exclude: ["node_modules", "dist", "**/*.test.ts"]
+        }, null, 2));
+        // .eslintrc.json (Architecture Guardrails)
+        const archStyle = options.architecture || "clean";
+        let restrictedPaths = [];
+        if (archStyle === "clean") {
+            restrictedPaths = [
+                {
+                    target: "./src/domain",
+                    from: "./src/application",
+                    message: "Domain layer cannot import from Application layer"
+                },
+                {
+                    target: "./src/domain",
+                    from: "./src/infrastructure",
+                    message: "Domain layer cannot import from Infrastructure layer"
+                },
+                {
+                    target: "./src/domain",
+                    from: "./src/interface-adapters",
+                    message: "Domain layer cannot import from Interface Adapters layer"
+                },
+                {
+                    target: "./src/application",
+                    from: "./src/infrastructure",
+                    message: "Application layer cannot import from Infrastructure layer"
+                },
+                {
+                    target: "./src/application",
+                    from: "./src/interface-adapters",
+                    message: "Application layer cannot import from Interface Adapters layer"
+                },
+                {
+                    target: "./src/infrastructure",
+                    from: "./src/interface-adapters",
+                    message: "Infrastructure layer cannot import from Interface Adapters layer"
+                }
+            ];
+        }
+        else if (archStyle === "mvc") {
+            restrictedPaths = [
+                {
+                    target: "./src/models",
+                    from: "./src/controllers",
+                    message: "Models cannot import from Controllers"
+                },
+                {
+                    target: "./src/models",
+                    from: "./src/routes",
+                    message: "Models cannot import from Routes"
+                },
+                {
+                    target: "./src/services",
+                    from: "./src/controllers",
+                    message: "Services cannot import from Controllers"
+                },
+                {
+                    target: "./src/services",
+                    from: "./src/routes",
+                    message: "Services cannot import from Routes"
+                }
+            ];
+        }
+        else {
+            restrictedPaths = [
+                {
+                    target: "./src/core",
+                    from: "./src/services",
+                    message: "Core cannot import from Services"
+                },
+                {
+                    target: "./src/core",
+                    from: "./src/api",
+                    message: "Core cannot import from API"
+                },
+                {
+                    target: "./src/services",
+                    from: "./src/api",
+                    message: "Services cannot import from API"
+                }
+            ];
+        }
+        this.writeFile(root, ".eslintrc.json", JSON.stringify({
+            "env": {
+                "es2021": true,
+                "node": true
+            },
+            "extends": [
+                "eslint:recommended",
+                "plugin:@typescript-eslint/recommended"
+            ],
+            "parser": "@typescript-eslint/parser",
+            "parserOptions": {
+                "ecmaVersion": "latest",
+                "sourceType": "module"
+            },
+            "plugins": [
+                "@typescript-eslint",
+                "import"
+            ],
+            "rules": {
+                "import/no-restricted-paths": ["error", {
+                        "zones": restrictedPaths
+                    }]
+            }
+        }, null, 2));
+        // .env
+        this.writeFile(root, ".env", `PORT=3000\nNODE_ENV=development\nDATABASE_URL="postgresql://user:password@localhost:5432/appdb?schema=public"\nREDIS_URL="redis://localhost:6379"\n`);
+        this.writeFile(root, ".env.example", `PORT=3000\nNODE_ENV=development\nDATABASE_URL="postgresql://user:password@localhost:5432/appdb?schema=public"\nREDIS_URL="redis://localhost:6379"\n`);
+        this.writeFile(root, ".gitignore", `node_modules/\ndist/\n.env\ncoverage/\n`);
+        this.generateConfig(root, options);
+        this.generateCacheLayer(root, options);
+        this.generateErrorHandling(root, options);
+        this.generateHealthChecks(root, options);
+    }
+    generateConfig(root, options) {
+        this.writeFile(root, "src/config/env.schema.ts", `
+import { z } from "zod";
+
+export const envSchema = z.object({
+    PORT: z.string().default("3000"),
+    NODE_ENV: z.enum(["development", "production", "test"]).default("development"),
+    DATABASE_URL: z.string(),
+    REDIS_URL: z.string().default("redis://localhost:6379"),
+    LOG_LEVEL: z.string().default("info"),
+});
+
+export type Env = z.infer<typeof envSchema>;
+        `);
+        this.writeFile(root, "src/config/index.ts", `
+import dotenv from "dotenv";
+import { envSchema } from "./env.schema";
+
+dotenv.config();
+
+const parsed = envSchema.safeParse(process.env);
+
+if (!parsed.success) {
+    console.error("❌ Invalid environment variables:", parsed.error.format());
+    process.exit(1);
+}
+
+export const config = {
+    app: {
+        port: parseInt(parsed.data.PORT, 10),
+        env: parsed.data.NODE_ENV,
+        logLevel: parsed.data.LOG_LEVEL,
+    },
+    database: {
+        url: parsed.data.DATABASE_URL,
+    },
+    cache: {
+        url: parsed.data.REDIS_URL,
+    },
+};
+        `);
+    }
+    generateCacheLayer(root, options) {
+        this.writeFile(root, "src/infrastructure/cache/cache.interface.ts", `
+export interface ICache {
+    get<T>(key: string): Promise<T | null>;
+    set(key: string, value: any, ttlSeconds?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+        `);
+        this.writeFile(root, "src/infrastructure/cache/redis.cache.ts", `
+import Redis from "ioredis";
+import { ICache } from "./cache.interface";
+import { config } from "../../config";
+import logger from "../logger";
+
+export class RedisCache implements ICache {
+    private redis: Redis;
+
+    constructor() {
+        this.redis = new Redis(config.cache.url);
+        this.redis.on("error", (err) => logger.error("Redis Error", err));
+    }
+
+    async get<T>(key: string): Promise<T | null> {
+        const data = await this.redis.get(key);
+        return data ? JSON.parse(data) : null;
+    }
+
+    async set(key: string, value: any, ttlSeconds?: number): Promise<void> {
+        const data = JSON.stringify(value);
+        if (ttlSeconds) {
+            await this.redis.setex(key, ttlSeconds, data);
+        } else {
+            await this.redis.set(key, data);
+        }
+    }
+
+    async delete(key: string): Promise<void> {
+        await this.redis.del(key);
+    }
+}
+        `);
+        this.writeFile(root, "src/infrastructure/cache/memory.cache.ts", `
+import { ICache } from "./cache.interface";
+
+export class MemoryCache implements ICache {
+    private cache = new Map<string, { value: any; expiresAt?: number }>();
+
+    async get<T>(key: string): Promise<T | null> {
+        const item = this.cache.get(key);
+        if (!item) return null;
+        if (item.expiresAt && item.expiresAt < Date.now()) {
+            this.cache.delete(key);
+            return null;
+        }
+        return item.value;
+    }
+
+    async set(key: string, value: any, ttlSeconds?: number): Promise<void> {
+        const expiresAt = ttlSeconds ? Date.now() + ttlSeconds * 1000 : undefined;
+        this.cache.set(key, { value, expiresAt });
+    }
+
+    async delete(key: string): Promise<void> {
+        this.cache.delete(key);
+    }
+}
+        `);
+    }
+    generateErrorHandling(root, options) {
+        this.writeFile(root, "src/infrastructure/errors/app.error.ts", `
+import { StatusCodes } from "http-status-codes";
+
+export class AppError extends Error {
+    constructor(
+        public message: string,
+        public statusCode: number = StatusCodes.INTERNAL_SERVER_ERROR,
+        public isOperational: boolean = true
+    ) {
+        super(message);
+        Object.setPrototypeOf(this, AppError.prototype);
+    }
+}
+
+export class NotFoundError extends AppError {
+    constructor(message: string = "Resource not found") {
+        super(message, StatusCodes.NOT_FOUND);
+    }
+}
+
+export class BadRequestError extends AppError {
+    constructor(message: string = "Bad request") {
+        super(message, StatusCodes.BAD_REQUEST);
+    }
+}
+        `);
+        this.writeFile(root, "src/infrastructure/middleware/error.middleware.ts", `
+import { Request, Response, NextFunction } from "express";
+import { AppError } from "../errors/app.error";
+import logger from "../logger";
+import { StatusCodes } from "http-status-codes";
+
+export const errorMiddleware = (
+    err: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+) => {
+    if (err instanceof AppError) {
+        return res.status(err.statusCode).json({
+            status: "error",
+            message: err.message,
+        });
+    }
+
+    logger.error("Unhandled Error", err);
+
+    return res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
+        status: "error",
+        message: "Something went wrong",
+    });
+};
+        `);
+    }
+    generateHealthChecks(root, options) {
+        this.writeFile(root, "src/interface-adapters/controllers/health.controller.ts", `
+import { Request, Response } from "express";
+import { StatusCodes } from "http-status-codes";
+import prisma from "../../infrastructure/database/prisma";
+
+export class HealthController {
+    async health(req: Request, res: Response) {
+        res.status(StatusCodes.OK).json({ status: "ok", timestamp: new Date().toISOString() });
+    }
+
+    async ready(req: Request, res: Response) {
+        const checks: any = {
+            uptime: process.uptime(),
+            timestamp: new Date().toISOString(),
+        };
+
+        try {
+            ${options.orm === 'prisma' ? 'await prisma.$queryRaw`SELECT 1`' : ''}
+            checks.database = "connected";
+        } catch (e) {
+            checks.database = "disconnected";
+            return res.status(StatusCodes.SERVICE_UNAVAILABLE).json({ status: "error", checks });
+        }
+
+        res.status(StatusCodes.OK).json({ status: "ok", checks });
+    }
+}
+        `);
+    }
+    generateCleanArchitecture(root, options) {
+        // Domain Layer
+        this.writeFile(root, "src/domain/entities/user.entity.ts", `
+export class User {
+    constructor(
+        public readonly id: string,
+        public readonly name: string,
+        public readonly email: string
+    ) {}
+}
+        `);
+        this.writeFile(root, "src/domain/repositories/user.repository.ts", `
+import { User } from "../entities/user.entity";
+
+export interface UserRepository {
+    save(user: User): Promise<User>;
+    findByEmail(email: string): Promise<User | null>;
+    findById(id: string): Promise<User | null>;
+}
+        `);
+        // Application Layer
+        this.writeFile(root, "src/application/use-cases/create-user.use-case.ts", `
+import { User } from "../../domain/entities/user.entity";
+import { UserRepository } from "../../domain/repositories/user.repository";
+import { BadRequestError } from "../../infrastructure/errors/app.error";
+
+export class CreateUserUseCase {
+    constructor(private userRepository: UserRepository) {}
+
+    async execute(name: string, email: string): Promise<User> {
+        const existing = await this.userRepository.findByEmail(email);
+        if (existing) throw new BadRequestError("User already exists");
+        
+        const user = new User(Date.now().toString(), name, email);
+        return this.userRepository.save(user);
+    }
+}
+        `);
+        this.writeFile(root, "src/application/use-cases/get-user.use-case.ts", `
+import { User } from "../../domain/entities/user.entity";
+import { UserRepository } from "../../domain/repositories/user.repository";
+import { NotFoundError } from "../../infrastructure/errors/app.error";
+import { ICache } from "../../infrastructure/cache/cache.interface";
+
+export class GetUserUseCase {
+    constructor(
+        private userRepository: UserRepository,
+        private cache: ICache
+    ) {}
+
+    async execute(id: string): Promise<User> {
+        const cacheKey = \`user:\${id}\`;
+        const cached = await this.cache.get<User>(cacheKey);
+        if (cached) return cached;
+
+        const user = await this.userRepository.findById(id);
+        if (!user) throw new NotFoundError("User not found");
+
+        await this.cache.set(cacheKey, user, 3600);
+        return user;
+    }
+}
+        `);
+        // Infrastructure Layer
+        this.writeFile(root, "src/infrastructure/persistence/in-memory-user.repository.ts", `
+import { User } from "../../domain/entities/user.entity";
+import { UserRepository } from "../../domain/repositories/user.repository";
+
+export class InMemoryUserRepository implements UserRepository {
+    private users: User[] = [];
+
+    async save(user: User): Promise<User> {
+        this.users.push(user);
+        return user;
+    }
+
+    async findByEmail(email: string): Promise<User | null> {
+        return this.users.find(u => u.email === email) || null;
+    }
+
+    async findById(id: string): Promise<User | null> {
+        return this.users.find(u => u.id === id) || null;
+    }
+}
+        `);
+        // Interface Adapters (Controllers)
+        this.writeFile(root, "src/interface-adapters/controllers/user.controller.ts", `
+import { Request, Response } from "express";
+import { StatusCodes } from "http-status-codes";
+import { CreateUserUseCase } from "../../application/use-cases/create-user.use-case";
+import { GetUserUseCase } from "../../application/use-cases/get-user.use-case";
+
+export class UserController {
+    constructor(
+        private createUserUseCase: CreateUserUseCase,
+        private getUserUseCase: GetUserUseCase
+    ) {}
+
+    async create(req: Request, res: Response) {
+        const { name, email } = req.body;
+        const user = await this.createUserUseCase.execute(name, email);
+        res.status(StatusCodes.CREATED).json(user);
+    }
+
+    async get(req: Request, res: Response) {
+        const { id } = req.params;
+        const user = await this.getUserUseCase.execute(id);
+        res.status(StatusCodes.OK).json(user);
+    }
+}
+        `);
+        // Main Entry Point
+        this.writeFile(root, "src/main.ts", `
+import "express-async-errors";
+import express from "express";
+import cors from "cors";
+import helmet from "helmet";
+import morgan from "morgan";
+import { v4 as uuidv4 } from "uuid";
+import { config } from "./config";
+import logger from "./infrastructure/logger";
+import { errorMiddleware } from "./infrastructure/middleware/error.middleware";
+import { InMemoryUserRepository } from "./infrastructure/persistence/in-memory-user.repository";
+import { MemoryCache } from "./infrastructure/cache/memory.cache";
+import { CreateUserUseCase } from "./application/use-cases/create-user.use-case";
+import { GetUserUseCase } from "./application/use-cases/get-user.use-case";
+import { UserController } from "./interface-adapters/controllers/user.controller";
+import { HealthController } from "./interface-adapters/controllers/health.controller";
+
+const app = express();
+
+// Security & Middleware
+app.use(helmet());
+app.use(express.json());
+app.use(cors());
+app.use(morgan("combined"));
+
+// Correlation ID & Logging
+app.use((req, res, next) => {
+    const correlationId = (req.headers["x-correlation-id"] as string) || uuidv4();
+    req.headers["x-correlation-id"] = correlationId;
+    res.setHeader("X-Correlation-ID", correlationId);
+    next();
+});
+
+// Dependency Injection
+const userRepository = new InMemoryUserRepository();
+const cache = new MemoryCache(); // Use RedisCache in production
+const createUserUseCase = new CreateUserUseCase(userRepository);
+const getUserUseCase = new GetUserUseCase(userRepository, cache);
+const userController = new UserController(createUserUseCase, getUserUseCase);
+const healthController = new HealthController();
+
+// Routes
+app.get("/health", (req, res) => healthController.health(req, res));
+app.get("/ready", (req, res) => healthController.ready(req, res));
+
+app.post("/users", (req, res) => userController.create(req, res));
+app.get("/users/:id", (req, res) => userController.get(req, res));
+
+// Error Handling
+app.use(errorMiddleware);
+
+const PORT = config.app.port;
+app.listen(PORT, () => {
+    logger.info(\`🚀 Server running in \${config.app.env} mode on port \${PORT}\`);
+});
+        `);
+    }
+    generateMVCArchitecture(root, options) {
+        // Model
+        this.writeFile(root, "src/models/user.model.ts", `
+export interface User {
+    id: string;
+    name: string;
+    email: string;
+}
+        `);
+        // Service (Business Logic)
+        this.writeFile(root, "src/services/user.service.ts", `
+import { User } from "../models/user.model";
+import { ICache } from "../infrastructure/cache/cache.interface";
+import { BadRequestError, NotFoundError } from "../infrastructure/errors/app.error";
+
+const users: User[] = [];
+
+export class UserService {
+    constructor(private cache: ICache) {}
+
+    async create(name: string, email: string): Promise<User> {
+        if (users.find(u => u.email === email)) {
+            throw new BadRequestError("User already exists");
+        }
+        const user = { id: Date.now().toString(), name, email };
+        users.push(user);
+        return user;
+    }
+
+    async getById(id: string): Promise<User> {
+        const cacheKey = \`user:\${id}\`;
+        const cached = await this.cache.get<User>(cacheKey);
+        if (cached) return cached;
+
+        const user = users.find(u => u.id === id);
+        if (!user) throw new NotFoundError("User not found");
+
+        await this.cache.set(cacheKey, user, 3600);
+        return user;
+    }
+}
+        `);
+        // Controller
+        this.writeFile(root, "src/controllers/user.controller.ts", `
+import { Request, Response } from "express";
+import { StatusCodes } from "http-status-codes";
+import { UserService } from "../services/user.service";
+
+export class UserController {
+    constructor(private userService: UserService) {}
+
+    async create(req: Request, res: Response) {
+        const { name, email } = req.body;
+        const user = await this.userService.create(name, email);
+        res.status(StatusCodes.CREATED).json(user);
+    }
+
+    async get(req: Request, res: Response) {
+        const { id } = req.params;
+        const user = await this.userService.getById(id);
+        res.status(StatusCodes.OK).json(user);
+    }
+}
+        `);
+        // Routes
+        this.writeFile(root, "src/routes/user.routes.ts", `
+import { Router } from "express";
+import { UserController } from "../controllers/user.controller";
+import { UserService } from "../services/user.service";
+import { MemoryCache } from "../infrastructure/cache/memory.cache";
+
+const router = Router();
+const cache = new MemoryCache();
+const userService = new UserService(cache);
+const userController = new UserController(userService);
+
+router.post("/", (req, res) => userController.create(req, res));
+router.get("/:id", (req, res) => userController.get(req, res));
+
+export default router;
+        `);
+        // Main
+        this.writeFile(root, "src/main.ts", `
+import "express-async-errors";
+import express from "express";
+import cors from "cors";
+import helmet from "helmet";
+import morgan from "morgan";
+import { config } from "./config";
+import logger from "./infrastructure/logger";
+import { errorMiddleware } from "./infrastructure/middleware/error.middleware";
+import userRoutes from "./routes/user.routes";
+import { HealthController } from "./interface-adapters/controllers/health.controller";
+
+const app = express();
+
+app.use(helmet());
+app.use(express.json());
+app.use(cors());
+app.use(morgan("combined"));
+
+const healthController = new HealthController();
+app.get("/health", (req, res) => healthController.health(req, res));
+app.get("/ready", (req, res) => healthController.ready(req, res));
+
+app.use("/users", userRoutes);
+
+app.use(errorMiddleware);
+
+const PORT = config.app.port;
+app.listen(PORT, () => {
+    logger.info(\`🚀 Server running in \${config.app.env} mode on port \${PORT}\`);
+});
+        `);
+    }
+    generateLayeredArchitecture(root, options) {
+        // Core Layer
+        this.writeFile(root, "src/core/types/user.ts", `
+export interface User {
+    id: string;
+    name: string;
+    email: string;
+}
+        `);
+        // Services Layer
+        this.writeFile(root, "src/services/user.service.ts", `
+import { User } from "../core/types/user";
+import { ICache } from "../infrastructure/cache/cache.interface";
+import { BadRequestError, NotFoundError } from "../infrastructure/errors/app.error";
+
+const users: User[] = [];
+
+export class UserService {
+    constructor(private cache: ICache) {}
+
+    async create(name: string, email: string): Promise<User> {
+        const user = { id: Date.now().toString(), name, email };
+        users.push(user);
+        return user;
+    }
+
+    async getById(id: string): Promise<User> {
+        const cacheKey = \`user:\${id}\`;
+        const cached = await this.cache.get<User>(cacheKey);
+        if (cached) return cached;
+
+        const user = users.find(u => u.id === id);
+        if (!user) throw new NotFoundError("User not found");
+
+        await this.cache.set(cacheKey, user, 3600);
+        return user;
+    }
+}
+        `);
+        // API Layer
+        this.writeFile(root, "src/api/routes/user.routes.ts", `
+import { Router } from "express";
+import { UserService } from "../../services/user.service";
+import { MemoryCache } from "../../infrastructure/cache/memory.cache";
+import { StatusCodes } from "http-status-codes";
+
+const router = Router();
+const cache = new MemoryCache();
+const userService = new UserService(cache);
+
+router.post("/", async (req, res) => {
+    const user = await userService.create(req.body.name, req.body.email);
+    res.status(StatusCodes.CREATED).json(user);
+});
+
+router.get("/:id", async (req, res) => {
+    const user = await userService.getById(req.params.id);
+    res.status(StatusCodes.OK).json(user);
+});
+
+export default router;
+        `);
+        // Main
+        this.writeFile(root, "src/main.ts", `
+import "express-async-errors";
+import express from "express";
+import helmet from "helmet";
+import cors from "cors";
+import { config } from "./config";
+import logger from "./infrastructure/logger";
+import { errorMiddleware } from "./infrastructure/middleware/error.middleware";
+import userRoutes from "./api/routes/user.routes";
+import { HealthController } from "./interface-adapters/controllers/health.controller";
+
+const app = express();
+app.use(helmet());
+app.use(express.json());
+app.use(cors());
+
+const healthController = new HealthController();
+app.get("/health", (req, res) => healthController.health(req, res));
+app.get("/ready", (req, res) => healthController.ready(req, res));
+
+app.use("/api/users", userRoutes);
+
+app.use(errorMiddleware);
+
+const PORT = config.app.port;
+app.listen(PORT, () => {
+    logger.info(\`🚀 Server running in \${config.app.env} mode on port \${PORT}\`);
+});
+        `);
+    }
+    generateDocker(root, options) {
+        const dbService = options.database === "postgresql" ? `
+  db:
+    image: postgres:15-alpine
+    environment:
+      - POSTGRES_USER=user
+      - POSTGRES_PASSWORD=password
+      - POSTGRES_DB=appdb
+    ports:
+      - "5432:5432"
+        ` : options.database === "mysql" ? `
+  db:
+    image: mysql:8
+    environment:
+      - MYSQL_ROOT_PASSWORD=password
+      - MYSQL_DATABASE=appdb
+    ports:
+      - "3306:3306"
+        ` : "";
+        const dbUrl = options.database === "postgresql" ? "postgresql://user:password@db:5432/appdb?schema=public" :
+            options.database === "mysql" ? "mysql://root:password@db:3306/appdb" : "";
+        this.writeFile(root, "Dockerfile", `
+FROM node:18-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+${options.orm === 'prisma' ? 'RUN npx prisma generate' : ''}
+RUN npm run build
+
+FROM node:18-alpine
+WORKDIR /app
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/package*.json ./
+${options.orm === 'prisma' ? 'COPY --from=builder /app/prisma ./prisma' : ''}
+RUN npm ci --production
+${options.orm === 'prisma' ? 'RUN npx prisma generate' : ''}
+EXPOSE 3000
+CMD ["npm", "start"]
+        `);
+        this.writeFile(root, "docker-compose.yml", `
+version: '3.8'
+services:
+  app:
+    build: .
+    ports:
+      - "3000:3000"
+    environment:
+      - PORT=3000
+      - NODE_ENV=production
+      ${dbUrl ? `- DATABASE_URL=\${DATABASE_URL:-${dbUrl}}` : ""}
+      - REDIS_URL=redis://cache:6379
+    depends_on:
+      ${dbService ? "- db" : ""}
+      - cache
+    restart: always
+  ${dbService}
+  cache:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+        `);
+    }
+    generateCI(root, options) {
+        this.writeFile(root, ".github/workflows/ci.yml", `
+name: CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js 18.x
+      uses: actions/setup-node@v3
+      with:
+        node-version: 18.x
+        cache: 'npm'
+    - run: npm ci
+    ${options.orm === 'prisma' ? '- run: npx prisma generate' : ''}
+    - name: Architecture Sync & Validation
+      run: npx archforge sync
+    - run: npm run lint
+    - run: npm test
+    - run: npm run build
+        `);
+    }
+    generatePrismaSchema(root, options) {
+        const provider = options.database === "mongodb" ? "mongodb" :
+            options.database === "mysql" ? "mysql" :
+                options.database === "sqlite" ? "sqlite" : "postgresql";
+        const url = options.database === "sqlite" ? "file:./dev.db" : "env(\"DATABASE_URL\")";
+        this.writeFile(root, "prisma/schema.prisma", `
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "${provider}"
+  url      = ${url}
+}
+
+model User {
+  id    String @id @default(uuid())
+  email String @unique
+  name  String?
+}
+        `);
+        this.writeFile(root, "src/infrastructure/database/prisma.ts", `
+import { PrismaClient } from "@prisma/client";
+
+const prisma = new PrismaClient();
+
+export default prisma;
+        `);
+    }
+}
+exports.ExpressGenerator = ExpressGenerator;