create-flex-stack 1.0.0

package/dist/templates/modularTemplate.js

@@ -0,0 +1,691 @@
+import { getMulterMiddleware, getTypeOrmConfig, getTypeOrmEntity } from './sharedTemplate.js';
+export function getModularFiles(options) {
+    const files = {};
+    const userIdExpr = options.orm === 'prisma' ? 'user.id' : 'user._id.toString()';
+    const validationImport = options.validation === 'zod'
+        ? `import { z } from 'zod';`
+        : `import Joi from 'joi';`;
+    // 1. src/config/env.ts
+    files['src/config/env.ts'] = options.validation === 'zod'
+        ? `import dotenv from 'dotenv';
+import { z } from 'zod';
+
+dotenv.config();
+
+const envSchema = z.object({
+  PORT: z.coerce.number().default(3000),
+  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
+  DATABASE_URL: z.string().min(1, 'DATABASE_URL is required'),
+  ${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),
+  NODE_ENV: Joi.string().valid('development', 'production', 'test').default('development'),
+  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),
+  NODE_ENV: value.NODE_ENV,
+  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,` : ''}
+};
+`;
+    // TypeORM data-source if TypeORM chosen
+    if (options.orm === 'typeorm') {
+        files['src/config/data-source.ts'] = getTypeOrmConfig(options)
+            .replace('../entities/user.entity.js', '../modules/users/users.entity.js')
+            .replace('UserEntity', 'UserEntity');
+    }
+    // 2. src/middlewares/errorHandler.ts
+    files['src/middlewares/errorHandler.ts'] = `import { Request, Response, NextFunction } from 'express';
+
+export class AppError extends Error {
+  constructor(public statusCode: number, message: string, public isOperational = true) {
+    super(message);
+    Object.setPrototypeOf(this, new.target.prototype);
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+export const errorHandler = (err: Error | AppError, req: Request, res: Response, next: NextFunction) => {
+  const statusCode = err instanceof AppError ? err.statusCode : 500;
+  const message = err.message || 'Internal Server Error';
+
+  res.status(statusCode).json({
+    status: 'error',
+    statusCode,
+    message,
+    ...(process.env.NODE_ENV === 'development' && { stack: err.stack }),
+  });
+};
+`;
+    // 3. Auth Middlewares
+    if (options.auth) {
+        files['src/middlewares/auth.ts'] = `import { Request, Response, NextFunction } from 'express';
+import jwt from 'jsonwebtoken';
+import { env } from '../config/env.js';
+import { AppError } from './errorHandler.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, 'Authentication token missing or invalid'));
+  }
+  const token = authHeader.split(' ')[1];
+  try {
+    const decoded = jwt.verify(token, env.JWT_SECRET) as any;
+    req.user = decoded;
+    next();
+  } catch (error) {
+    next(new AppError(401, 'Authentication token expired or corrupt'));
+  }
+};
+`;
+        if (options.rbac) {
+            files['src/middlewares/rbac.ts'] = `import { Response, NextFunction } from 'express';
+import { AuthenticatedRequest } from './auth.js';
+import { AppError } from './errorHandler.js';
+
+export const authorize = (...roles: string[]) => {
+  return (req: AuthenticatedRequest, res: Response, next: NextFunction) => {
+    if (!req.user) return next(new AppError(401, 'User not authenticated'));
+    if (!roles.includes(req.user.role)) {
+      return next(new AppError(403, 'Permission denied: insufficient privileges'));
+    }
+    next();
+  };
+};
+`;
+        }
+    }
+    // 4. Caching & rate limiting
+    if (options.rateLimiting) {
+        files['src/middlewares/rateLimiter.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.',
+  },
+});
+`;
+    }
+    if (options.fileUpload) {
+        files['src/middlewares/upload.ts'] = getMulterMiddleware();
+    }
+    // Request validation helper
+    files['src/middlewares/validate.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;
+      req.query = parsed.query;
+      req.params = parsed.params;
+      next();
+    } catch (error) {
+      if (error instanceof ZodError) {
+        res.status(400).json({
+          status: 'error',
+          statusCode: 400,
+          message: 'Validation failed',
+          errors: error.errors.map(err => ({
+            field: err.path.join('.'),
+            message: err.message,
+          })),
+        });
+      } 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) => {
+    try {
+      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.map(err => ({
+            field: err.path.join('.'),
+            message: err.message,
+          })),
+        });
+      }
+      req.body = value.body;
+      req.query = value.query;
+      req.params = value.params;
+      next();
+    } catch (err) {
+      next(err);
+    }
+  };
+};
+`;
+    // 5. USER FEATURE MODULE
+    // Users Entity / Model
+    if (options.orm === 'typeorm') {
+        files['src/modules/users/users.entity.ts'] = getTypeOrmEntity();
+    }
+    else if (options.orm === 'mongoose') {
+        files['src/modules/users/users.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);
+`;
+    }
+    // Users DTO / Schemas
+    if (options.validation === 'zod') {
+        files['src/modules/users/users.dto.ts'] = `import { z } from 'zod';
+
+export const registerSchema = z.object({
+  body: z.object({
+    email: z.string().email('Invalid email address'),
+    name: z.string().min(2).optional(),
+    password: z.string().min(6, 'Password must be at least 6 characters'),
+    role: z.enum(['user', 'admin']).optional(),
+  }),
+});
+
+export const loginSchema = z.object({
+  body: z.object({
+    email: z.string().email('Invalid email address'),
+    password: z.string().min(1, 'Password is required'),
+  }),
+});
+
+export const refreshSchema = z.object({
+  body: z.object({
+    refreshToken: z.string().min(1, 'Refresh token is required'),
+  }),
+});
+`;
+    }
+    else {
+        files['src/modules/users/users.dto.ts'] = `import Joi from 'joi';
+
+export const registerSchema = Joi.object({
+  body: Joi.object({
+    email: Joi.string().email().required(),
+    name: Joi.string().min(2).optional(),
+    password: Joi.string().min(6).required(),
+    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);
+`;
+    }
+    // Users Repository
+    if (options.orm === 'prisma') {
+        files['src/modules/users/users.repository.ts'] = `import { PrismaClient } from '@prisma/client';
+
+const prisma = new PrismaClient();
+
+export class UsersRepository {
+  async findByEmail(email: string) {
+    return prisma.user.findUnique({ where: { email } });
+  }
+  async findById(id: string) {
+    return prisma.user.findUnique({ where: { id } });
+  }
+  async create(data: any) {
+    return prisma.user.create({ data });
+  }
+  async update(id: string, data: any) {
+    return prisma.user.update({ where: { id }, data });
+  }
+  async findAll() {
+    return prisma.user.findMany({
+      select: { id: true, email: true, name: true, role: true, createdAt: true }
+    });
+  }
+}
+`;
+    }
+    else if (options.orm === 'typeorm') {
+        files['src/modules/users/users.repository.ts'] = `import { AppDataSource } from '../../config/data-source.js';
+import { UserEntity } from './users.entity.js';
+
+export class UsersRepository {
+  private repo = AppDataSource.getRepository(UserEntity);
+
+  async findByEmail(email: string) {
+    return this.repo.findOne({ where: { email } });
+  }
+  async findById(id: string) {
+    return this.repo.findOne({ where: { id } });
+  }
+  async create(data: any) {
+    const user = this.repo.create(data);
+    return this.repo.save(user);
+  }
+  async update(id: string, data: any) {
+    await this.repo.update(id, data);
+    return this.findById(id);
+  }
+  async findAll() {
+    return this.repo.find({
+      select: ["id", "email", "name", "role", "createdAt"]
+    });
+  }
+}
+`;
+    }
+    else {
+        // Mongoose
+        files['src/modules/users/users.repository.ts'] = `import { UserModel } from './users.model.js';
+
+export class UsersRepository {
+  async findByEmail(email: string) {
+    return UserModel.findOne({ email });
+  }
+  async findById(id: string) {
+    return UserModel.findById(id);
+  }
+  async create(data: any) {
+    return UserModel.create(data);
+  }
+  async update(id: string, data: any) {
+    return UserModel.findByIdAndUpdate(id, data, { new: true });
+  }
+  async findAll() {
+    return UserModel.find({}, 'id email name role createdAt');
+  }
+}
+`;
+    }
+    // Users Service
+    files['src/modules/users/users.service.ts'] = `import bcrypt from 'bcryptjs';
+import jwt from 'jsonwebtoken';
+import { UsersRepository } from './users.repository.js';
+import { env } from '../../config/env.js';
+import { AppError } from '../../middlewares/errorHandler.js';
+
+const usersRepository = new UsersRepository();
+
+export class UsersService {
+  private 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 };
+  }
+
+  async register(data: any) {
+    const existing = await usersRepository.findByEmail(data.email);
+    if (existing) throw new AppError(400, 'Email already registered');
+
+    const hashedPassword = await bcrypt.hash(data.password, 10);
+    const user = await usersRepository.create({ ...data, password: hashedPassword });
+    const userId = ${userIdExpr};
+
+    const tokens = this.generateTokens({ id: userId, email: user.email, role: user.role });
+    await usersRepository.update(userId, { refreshToken: tokens.refreshToken });
+
+    return {
+      user: { id: userId, email: user.email, name: user.name, role: user.role },
+      ...tokens
+    };
+  }
+
+  async login(data: any) {
+    const user = await usersRepository.findByEmail(data.email);
+    if (!user) throw new AppError(401, 'Invalid email or password');
+
+    const isMatch = await bcrypt.compare(data.password, user.password);
+    if (!isMatch) throw new AppError(401, 'Invalid email or password');
+
+    const userId = ${userIdExpr};
+    const tokens = this.generateTokens({ id: userId, email: user.email, role: user.role });
+    await usersRepository.update(userId, { refreshToken: tokens.refreshToken });
+
+    return {
+      user: { id: userId, email: user.email, name: user.name, role: user.role },
+      ...tokens
+    };
+  }
+
+  async refresh(token: string) {
+    try {
+      const decoded = jwt.verify(token, env.JWT_REFRESH_SECRET) as any;
+      const user = await usersRepository.findById(decoded.id);
+      if (!user || user.refreshToken !== token) {
+        throw new AppError(401, 'Invalid or revoked refresh token');
+      }
+      const userId = ${userIdExpr};
+      const tokens = this.generateTokens({ id: userId, email: user.email, role: user.role });
+      await usersRepository.update(userId, { refreshToken: tokens.refreshToken });
+      return tokens;
+    } catch (err) {
+      throw new AppError(401, 'Invalid or expired refresh token');
+    }
+  }
+
+  async getProfile(id: string) {
+    const user = await usersRepository.findById(id);
+    if (!user) throw new AppError(404, 'User not found');
+    return {
+      id: ${userIdExpr},
+      email: user.email,
+      name: user.name,
+      role: user.role,
+      createdAt: user.createdAt
+    };
+  }
+
+  async getAllUsers() {
+    return usersRepository.findAll();
+  }
+}
+`;
+    // Users Controller
+    files['src/modules/users/users.controller.ts'] = `import { Request, Response, NextFunction } from 'express';
+import { UsersService } from './users.service.js';
+import { AuthenticatedRequest } from '../../middlewares/auth.js';
+
+const usersService = new UsersService();
+
+export class UsersController {
+  async register(req: Request, res: Response, next: NextFunction) {
+    try {
+      const result = await usersService.register(req.body);
+      res.status(201).json({ status: 'success', data: result });
+    } catch (err) {
+      next(err);
+    }
+  }
+  async login(req: Request, res: Response, next: NextFunction) {
+    try {
+      const result = await usersService.login(req.body);
+      res.status(200).json({ status: 'success', data: result });
+    } catch (err) {
+      next(err);
+    }
+  }
+  async refresh(req: Request, res: Response, next: NextFunction) {
+    try {
+      const result = await usersService.refresh(req.body.refreshToken);
+      res.status(200).json({ status: 'success', data: result });
+    } catch (err) {
+      next(err);
+    }
+  }
+  async profile(req: AuthenticatedRequest, res: Response, next: NextFunction) {
+    try {
+      const user = await usersService.getProfile(req.user!.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 usersService.getAllUsers();
+      res.status(200).json({ status: 'success', data: { users } });
+    } catch (err) {
+      next(err);
+    }
+  }
+}
+`;
+    // Users Routes
+    files['src/modules/users/users.routes.ts'] = `import { Router } from 'express';
+import { UsersController } from './users.controller.js';
+import { requireAuth } from '../../middlewares/auth.js';
+${options.rbac ? `import { authorize } from '../../middlewares/rbac.js';` : ''}
+import { validate } from '../../middlewares/validate.js';
+import { registerSchema, loginSchema, refreshSchema } from './users.dto.js';
+
+const router = Router();
+const controller = new UsersController();
+
+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;
+`;
+    // 6. SECONDARY SAMPLE FEATURE MODULE: PRODUCTS
+    files['src/modules/products/products.entity.ts'] = options.orm === 'typeorm'
+        ? `import { Entity, PrimaryGeneratedColumn, Column } from "typeorm";
+
+@Entity({ name: "products" })
+export class ProductEntity {
+  @PrimaryGeneratedColumn("uuid")
+  id!: string;
+
+  @Column()
+  name!: string;
+
+  @Column("decimal", { precision: 10, scale: 2 })
+  price!: number;
+}
+`
+        : '';
+    files['src/modules/products/products.service.ts'] = `export class ProductsService {
+  async getProducts() {
+    return [
+      { id: '1', name: 'Product A', price: 99.99 },
+      { id: '2', name: 'Product B', price: 149.50 }
+    ];
+  }
+}
+`;
+    files['src/modules/products/products.controller.ts'] = `import { Request, Response, NextFunction } from 'express';
+import { ProductsService } from './products.service.js';
+
+const service = new ProductsService();
+
+export class ProductsController {
+  async list(req: Request, res: Response, next: NextFunction) {
+    try {
+      const products = await service.getProducts();
+      res.status(200).json({ status: 'success', data: { products } });
+    } catch (err) {
+      next(err);
+    }
+  }
+}
+`;
+    files['src/modules/products/products.routes.ts'] = `import { Router } from 'express';
+import { ProductsController } from './products.controller.js';
+
+const router = Router();
+const controller = new ProductsController();
+
+router.get('/', controller.list);
+
+export default router;
+`;
+    // 7. Core Express Router and Application Setup
+    files['src/routes.ts'] = `import { Router } from 'express';
+import userRoutes from './modules/users/users.routes.js';
+import productRoutes from './modules/products/products.routes.js';
+
+const router = Router();
+
+router.use('/users', userRoutes);
+router.use('/products', productRoutes);
+
+export default router;
+`;
+    // Express Setup (app.ts)
+    let appMiddlewaresImport = '';
+    let appMiddlewares = '';
+    if (options.rateLimiting) {
+        appMiddlewaresImport += `import { apiLimiter } from './middlewares/rateLimiter.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 (Modular)", 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/app.ts'] = `import express from 'express';
+import cors from 'cors';
+import helmet from 'helmet';
+import routes from './routes.js';
+import { errorHandler } from './middlewares/errorHandler.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;
+`;
+    // Server bootstrap (server.ts)
+    let dbConnectionCode = '';
+    if (options.orm === 'mongoose') {
+        dbConnectionCode = `import mongoose from 'mongoose';
+async function connectDB() {
+  await mongoose.connect(env.DATABASE_URL);
+  console.log('🔌 Connected to MongoDB database successfully.');
+}`;
+    }
+    else if (options.orm === 'typeorm') {
+        dbConnectionCode = `import { AppDataSource } from './config/data-source.js';
+async function connectDB() {
+  await AppDataSource.initialize();
+  console.log('🔌 Connected to Database via TypeORM datasource.');
+}`;
+    }
+    else {
+        dbConnectionCode = `import { PrismaClient } from '@prisma/client';
+const prisma = new PrismaClient();
+async function connectDB() {
+  await prisma.$connect();
+  console.log('🔌 Connected to Database via Prisma client.');
+}`;
+    }
+    files['src/server.ts'] = `import app from './app.js';
+import { env } from './config/env.js';
+${dbConnectionCode}
+
+const PORT = env.PORT || 3000;
+
+async function start() {
+  try {
+    await connectDB();
+    app.listen(PORT, () => {
+      console.log(\`🚀 Server running in \${env.NODE_ENV} mode on port \${PORT} (Modular Feature architecture)\`);
+      ${options.swagger ? `console.log(\`📄 Swagger Docs: http://localhost:\${PORT}/docs\`);` : ''}
+    });
+  } catch (err) {
+    console.error('❌ Failed to start application:', err);
+    process.exit(1);
+  }
+}
+
+start();
+`;
+    return files;
+}