@sachin-thakur/create-nodejs-app 1.0.0

package/src/templates/mvc.js

@@ -0,0 +1,890 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+async function generateMVCStructure(srcPath, config) {
+  const ext = config.language === 'typescript' ? 'ts' : 'js';
+  const isTS = config.language === 'typescript';
+
+  // Create directory structure
+  const dirs = ['config', 'controllers', 'models', 'routes', 'middlewares', 'services', 'utils'];
+  for (const dir of dirs) {
+    await fs.ensureDir(path.join(srcPath, dir));
+  }
+
+  // Generate main index file
+  await generateIndexFile(srcPath, config, ext, isTS);
+
+  // Generate config files
+  await generateConfigFiles(path.join(srcPath, 'config'), config, ext, isTS);
+
+  // Generate middleware files
+  await generateMiddlewareFiles(path.join(srcPath, 'middlewares'), config, ext, isTS);
+
+  // Generate utility files
+  await generateUtilityFiles(path.join(srcPath, 'utils'), config, ext, isTS);
+
+  // Generate controllers
+  await generateControllers(path.join(srcPath, 'controllers'), config, ext, isTS);
+
+  // Generate routes
+  await generateRoutes(path.join(srcPath, 'routes'), config, ext, isTS);
+
+  // Generate models
+  if (config.database !== 'none') {
+    await generateModels(path.join(srcPath, 'models'), config, ext, isTS);
+  }
+
+  // Generate services
+  await generateServices(path.join(srcPath, 'services'), config, ext, isTS);
+}
+
+async function generateIndexFile(srcPath, config, ext, isTS) {
+  const imports = isTS 
+    ? `import express, { Application } from 'express';
+import dotenv from 'dotenv';
+import cors from 'cors';
+${config.features.includes('logging') ? "import morgan from 'morgan';" : ''}
+${config.features.includes('rate-limit') ? "import rateLimit from 'express-rate-limit';" : ''}
+import { errorHandler } from './middlewares/errorHandler';
+${config.features.includes('logging') ? "import logger from './config/logger';" : ''}
+${config.database !== 'none' ? "import { connectDatabase } from './config/database';" : ''}
+import routes from './routes';
+${config.features.includes('swagger') ? "import { setupSwagger } from './config/swagger';" : ''}`
+    : `const express = require('express');
+const dotenv = require('dotenv');
+const cors = require('cors');
+${config.features.includes('logging') ? "const morgan = require('morgan');" : ''}
+${config.features.includes('rate-limit') ? "const rateLimit = require('express-rate-limit');" : ''}
+const { errorHandler } = require('./middlewares/errorHandler');
+${config.features.includes('logging') ? "const logger = require('./config/logger');" : ''}
+${config.database !== 'none' ? "const { connectDatabase } = require('./config/database');" : ''}
+const routes = require('./routes');
+${config.features.includes('swagger') ? "const { setupSwagger } = require('./config/swagger');" : ''}`;
+
+  const indexContent = `${imports}
+
+// Load environment variables
+dotenv.config();
+
+const app${isTS ? ': Application' : ''} = express();
+const PORT = process.env.PORT || 3000;
+
+// Middleware
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+app.use(cors(${config.features.includes('cors') ? `{
+  origin: process.env.CORS_ORIGIN || '*',
+  credentials: true,
+}` : ''}));
+
+${config.features.includes('logging') ? `// Request logging
+app.use(morgan('combined', { stream: { write: (message) => logger.info(message.trim()) } }));
+` : ''}
+${config.features.includes('rate-limit') ? `// Rate limiting
+const limiter = rateLimit({
+  windowMs: parseInt(process.env.RATE_LIMIT_WINDOW_MS || '900000'),
+  max: parseInt(process.env.RATE_LIMIT_MAX_REQUESTS || '100'),
+  message: 'Too many requests from this IP, please try again later.',
+});
+app.use('/api/', limiter);
+` : ''}
+// Routes
+app.use('/api', routes);
+
+// Health check
+app.get('/health', (req, res) => {
+  res.status(200).json({ status: 'OK', timestamp: new Date().toISOString() });
+});
+
+${config.features.includes('swagger') ? `// API Documentation
+setupSwagger(app);
+` : ''}
+// Error handling middleware (must be last)
+app.use(errorHandler);
+
+// Start server
+async function startServer() {
+  try {
+${config.database !== 'none' ? `    // Connect to database
+    await connectDatabase();
+` : ''}    
+    app.listen(PORT, () => {
+      ${config.features.includes('logging') ? `logger.info(\`Server running on port \${PORT}\`);` : `console.log(\`Server running on port \${PORT}\`);`}
+      ${config.features.includes('swagger') ? `console.log(\`API Documentation: http://localhost:\${PORT}/api-docs\`);` : ''}
+    });
+  } catch (error) {
+    ${config.features.includes('logging') ? `logger.error('Failed to start server:', error);` : `console.error('Failed to start server:', error);`}
+    process.exit(1);
+  }
+}
+
+startServer();
+
+${isTS ? 'export default app;' : 'module.exports = app;'}
+`;
+
+  await fs.writeFile(path.join(srcPath, `index.${ext}`), indexContent);
+}
+
+async function generateConfigFiles(configPath, config, ext, isTS) {
+  // Database config
+  if (config.database === 'postgresql') {
+    const dbConfig = isTS
+      ? `import { Pool } from 'pg';
+import logger from './logger';
+
+const pool = new Pool({
+  host: process.env.DB_HOST || 'localhost',
+  port: parseInt(process.env.DB_PORT || '5432'),
+  database: process.env.DB_NAME,
+  user: process.env.DB_USER,
+  password: process.env.DB_PASSWORD,
+});
+
+pool.on('connect', () => {
+  logger.info('Connected to PostgreSQL database');
+});
+
+pool.on('error', (err) => {
+  logger.error('Unexpected error on PostgreSQL client', err);
+});
+
+export async function connectDatabase(): Promise<void> {
+  try {
+    await pool.query('SELECT NOW()');
+    logger.info('Database connection established');
+  } catch (error) {
+    logger.error('Failed to connect to database:', error);
+    throw error;
+  }
+}
+
+export { pool };
+export default pool;`
+      : `const { Pool } = require('pg');
+${config.features.includes('logging') ? "const logger = require('./logger');" : ''}
+
+const pool = new Pool({
+  host: process.env.DB_HOST || 'localhost',
+  port: parseInt(process.env.DB_PORT || '5432'),
+  database: process.env.DB_NAME,
+  user: process.env.DB_USER,
+  password: process.env.DB_PASSWORD,
+});
+
+pool.on('connect', () => {
+  ${config.features.includes('logging') ? "logger.info('Connected to PostgreSQL database');" : "console.log('Connected to PostgreSQL database');"}
+});
+
+pool.on('error', (err) => {
+  ${config.features.includes('logging') ? "logger.error('Unexpected error on PostgreSQL client', err);" : "console.error('Unexpected error on PostgreSQL client', err);"}
+});
+
+async function connectDatabase() {
+  try {
+    await pool.query('SELECT NOW()');
+    ${config.features.includes('logging') ? "logger.info('Database connection established');" : "console.log('Database connection established');"}
+  } catch (error) {
+    ${config.features.includes('logging') ? "logger.error('Failed to connect to database:', error);" : "console.error('Failed to connect to database:', error);"}
+    throw error;
+  }
+}
+
+module.exports = { pool, connectDatabase };`;
+
+    await fs.writeFile(path.join(configPath, `database.${ext}`), dbConfig);
+  } else if (config.database === 'mongodb') {
+    const dbConfig = isTS
+      ? `import mongoose from 'mongoose';
+import logger from './logger';
+
+export async function connectDatabase(): Promise<void> {
+  try {
+    const uri = process.env.MONGODB_URI || 'mongodb://localhost:27017/myapp';
+    await mongoose.connect(uri);
+    logger.info('Connected to MongoDB');
+  } catch (error) {
+    logger.error('MongoDB connection error:', error);
+    throw error;
+  }
+}
+
+mongoose.connection.on('disconnected', () => {
+  logger.warn('MongoDB disconnected');
+});
+
+export default mongoose;`
+      : `const mongoose = require('mongoose');
+${config.features.includes('logging') ? "const logger = require('./logger');" : ''}
+
+async function connectDatabase() {
+  try {
+    const uri = process.env.MONGODB_URI || 'mongodb://localhost:27017/myapp';
+    await mongoose.connect(uri);
+    ${config.features.includes('logging') ? "logger.info('Connected to MongoDB');" : "console.log('Connected to MongoDB');"}
+  } catch (error) {
+    ${config.features.includes('logging') ? "logger.error('MongoDB connection error:', error);" : "console.error('MongoDB connection error:', error);"}
+    throw error;
+  }
+}
+
+mongoose.connection.on('disconnected', () => {
+  ${config.features.includes('logging') ? "logger.warn('MongoDB disconnected');" : "console.log('MongoDB disconnected');"}
+});
+
+module.exports = { connectDatabase, mongoose };`;
+
+    await fs.writeFile(path.join(configPath, `database.${ext}`), dbConfig);
+  }
+
+  // Logger config
+  if (config.features.includes('logging')) {
+    const loggerConfig = isTS
+      ? `import winston from 'winston';
+import path from 'path';
+
+const logger = winston.createLogger({
+  level: process.env.LOG_LEVEL || 'info',
+  format: winston.format.combine(
+    winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+    winston.format.errors({ stack: true }),
+    winston.format.splat(),
+    winston.format.json()
+  ),
+  defaultMeta: { service: 'app' },
+  transports: [
+    new winston.transports.File({
+      filename: path.join('logs', 'error.log'),
+      level: 'error',
+    }),
+    new winston.transports.File({
+      filename: path.join('logs', 'combined.log'),
+    }),
+  ],
+});
+
+if (process.env.NODE_ENV !== 'production') {
+  logger.add(
+    new winston.transports.Console({
+      format: winston.format.combine(
+        winston.format.colorize(),
+        winston.format.simple()
+      ),
+    })
+  );
+}
+
+export default logger;`
+      : `const winston = require('winston');
+const path = require('path');
+
+const logger = winston.createLogger({
+  level: process.env.LOG_LEVEL || 'info',
+  format: winston.format.combine(
+    winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+    winston.format.errors({ stack: true }),
+    winston.format.splat(),
+    winston.format.json()
+  ),
+  defaultMeta: { service: 'app' },
+  transports: [
+    new winston.transports.File({
+      filename: path.join('logs', 'error.log'),
+      level: 'error',
+    }),
+    new winston.transports.File({
+      filename: path.join('logs', 'combined.log'),
+    }),
+  ],
+});
+
+if (process.env.NODE_ENV !== 'production') {
+  logger.add(
+    new winston.transports.Console({
+      format: winston.format.combine(
+        winston.format.colorize(),
+        winston.format.simple()
+      ),
+    })
+  );
+}
+
+module.exports = logger;`;
+
+    await fs.writeFile(path.join(configPath, `logger.${ext}`), loggerConfig);
+  }
+
+  // Swagger config
+  if (config.features.includes('swagger')) {
+    const swaggerConfig = isTS
+      ? `import swaggerJsdoc from 'swagger-jsdoc';
+import swaggerUi from 'swagger-ui-express';
+import { Application } from 'express';
+
+const options = {
+  definition: {
+    openapi: '3.0.0',
+    info: {
+      title: 'API Documentation',
+      version: '1.0.0',
+      description: 'API documentation for the application',
+    },
+    servers: [
+      {
+        url: \`http://localhost:\${process.env.PORT || 3000}\`,
+        description: 'Development server',
+      },
+    ],
+    components: {
+      securitySchemes: {
+        bearerAuth: {
+          type: 'http',
+          scheme: 'bearer',
+          bearerFormat: 'JWT',
+        },
+      },
+    },
+  },
+  apis: ['./src/routes/*.${ext}'],
+};
+
+const specs = swaggerJsdoc(options);
+
+export function setupSwagger(app: Application): void {
+  app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(specs));
+}
+
+export default specs;`
+      : `const swaggerJsdoc = require('swagger-jsdoc');
+const swaggerUi = require('swagger-ui-express');
+
+const options = {
+  definition: {
+    openapi: '3.0.0',
+    info: {
+      title: 'API Documentation',
+      version: '1.0.0',
+      description: 'API documentation for the application',
+    },
+    servers: [
+      {
+        url: \`http://localhost:\${process.env.PORT || 3000}\`,
+        description: 'Development server',
+      },
+    ],
+    components: {
+      securitySchemes: {
+        bearerAuth: {
+          type: 'http',
+          scheme: 'bearer',
+          bearerFormat: 'JWT',
+        },
+      },
+    },
+  },
+  apis: ['./src/routes/*.${ext}'],
+};
+
+const specs = swaggerJsdoc(options);
+
+function setupSwagger(app) {
+  app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(specs));
+}
+
+module.exports = { setupSwagger, specs };`;
+
+    await fs.writeFile(path.join(configPath, `swagger.${ext}`), swaggerConfig);
+  }
+}
+
+async function generateMiddlewareFiles(middlewarePath, config, ext, isTS) {
+  // Error handler
+  const errorHandler = isTS
+    ? `import { Request, Response, NextFunction } from 'express';
+${config.features.includes('logging') ? "import logger from '../config/logger';" : ''}
+
+export class AppError extends Error {
+  statusCode: number;
+  isOperational: boolean;
+
+  constructor(message: string, statusCode: number = 500) {
+    super(message);
+    this.statusCode = statusCode;
+    this.isOperational = true;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+export function errorHandler(
+  err: AppError | Error,
+  req: Request,
+  res: Response,
+  next: NextFunction
+): void {
+  const statusCode = 'statusCode' in err ? err.statusCode : 500;
+  const message = err.message || 'Internal Server Error';
+
+  ${config.features.includes('logging') ? `logger.error({
+    message: err.message,
+    stack: err.stack,
+    url: req.url,
+    method: req.method,
+  });` : `console.error('Error:', {
+    message: err.message,
+    stack: err.stack,
+    url: req.url,
+    method: req.method,
+  });`}
+
+  res.status(statusCode).json({
+    success: false,
+    message,
+    ...(process.env.NODE_ENV === 'development' && { stack: err.stack }),
+  });
+}`
+    : `${config.features.includes('logging') ? "const logger = require('../config/logger');" : ''}
+
+class AppError extends Error {
+  constructor(message, statusCode = 500) {
+    super(message);
+    this.statusCode = statusCode;
+    this.isOperational = true;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+function errorHandler(err, req, res, next) {
+  const statusCode = err.statusCode || 500;
+  const message = err.message || 'Internal Server Error';
+
+  ${config.features.includes('logging') ? `logger.error({
+    message: err.message,
+    stack: err.stack,
+    url: req.url,
+    method: req.method,
+  });` : `console.error('Error:', {
+    message: err.message,
+    stack: err.stack,
+    url: req.url,
+    method: req.method,
+  });`}
+
+  res.status(statusCode).json({
+    success: false,
+    message,
+    ...(process.env.NODE_ENV === 'development' && { stack: err.stack }),
+  });
+}
+
+module.exports = { errorHandler, AppError };`;
+
+  await fs.writeFile(path.join(middlewarePath, `errorHandler.${ext}`), errorHandler);
+
+  // Auth middleware (if auth feature is enabled)
+  if (config.features.includes('auth')) {
+    const authMiddleware = isTS
+      ? `import { Request, Response, NextFunction } from 'express';
+import jwt from 'jsonwebtoken';
+import { AppError } from './errorHandler';
+
+export interface AuthRequest extends Request {
+  user?: any;
+}
+
+export function authenticate(
+  req: AuthRequest,
+  res: Response,
+  next: NextFunction
+): void {
+  try {
+    const token = req.headers.authorization?.split(' ')[1];
+
+    if (!token) {
+      throw new AppError('No token provided', 401);
+    }
+
+    const decoded = jwt.verify(token, process.env.JWT_SECRET || 'secret');
+    req.user = decoded;
+    next();
+  } catch (error) {
+    next(new AppError('Invalid or expired token', 401));
+  }
+}`
+      : `const jwt = require('jsonwebtoken');
+const { AppError } = require('./errorHandler');
+
+function authenticate(req, res, next) {
+  try {
+    const token = req.headers.authorization?.split(' ')[1];
+
+    if (!token) {
+      throw new AppError('No token provided', 401);
+    }
+
+    const decoded = jwt.verify(token, process.env.JWT_SECRET || 'secret');
+    req.user = decoded;
+    next();
+  } catch (error) {
+    next(new AppError('Invalid or expired token', 401));
+  }
+}
+
+module.exports = { authenticate };`;
+
+    await fs.writeFile(path.join(middlewarePath, `auth.${ext}`), authMiddleware);
+  }
+
+  // Validation middleware (if validation feature is enabled)
+  if (config.features.includes('validation')) {
+    const validationMiddleware = isTS
+      ? `import { Request, Response, NextFunction } from 'express';
+import { AnyZodObject, ZodError } from 'zod';
+import { AppError } from './errorHandler';
+
+export function validate(schema: AnyZodObject) {
+  return async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      await schema.parseAsync({
+        body: req.body,
+        query: req.query,
+        params: req.params,
+      });
+      next();
+    } catch (error) {
+      if (error instanceof ZodError) {
+        const message = error.errors.map((e) => e.message).join(', ');
+        next(new AppError(message, 400));
+      } else {
+        next(error);
+      }
+    }
+  };
+}`
+      : `const { AppError } = require('./errorHandler');
+
+function validate(schema) {
+  return async (req, res, next) => {
+    try {
+      await schema.parseAsync({
+        body: req.body,
+        query: req.query,
+        params: req.params,
+      });
+      next();
+    } catch (error) {
+      if (error.name === 'ZodError') {
+        const message = error.errors.map((e) => e.message).join(', ');
+        next(new AppError(message, 400));
+      } else {
+        next(error);
+      }
+    }
+  };
+}
+
+module.exports = { validate };`;
+
+    await fs.writeFile(path.join(middlewarePath, `validation.${ext}`), validationMiddleware);
+  }
+}
+
+async function generateUtilityFiles(utilsPath, config, ext, isTS) {
+  // Response helper
+  const responseHelper = isTS
+    ? `import { Response } from 'express';
+
+export function sendSuccess(res: Response, data: any, message: string = 'Success', statusCode: number = 200): void {
+  res.status(statusCode).json({
+    success: true,
+    message,
+    data,
+  });
+}
+
+export function sendError(res: Response, message: string, statusCode: number = 500): void {
+  res.status(statusCode).json({
+    success: false,
+    message,
+  });
+}`
+    : `function sendSuccess(res, data, message = 'Success', statusCode = 200) {
+  res.status(statusCode).json({
+    success: true,
+    message,
+    data,
+  });
+}
+
+function sendError(res, message, statusCode = 500) {
+  res.status(statusCode).json({
+    success: false,
+    message,
+  });
+}
+
+module.exports = { sendSuccess, sendError };`;
+
+  await fs.writeFile(path.join(utilsPath, `response.${ext}`), responseHelper);
+}
+
+async function generateControllers(controllersPath, config, ext, isTS) {
+  const healthController = isTS
+    ? `import { Request, Response, NextFunction } from 'express';
+import { sendSuccess } from '../utils/response';
+
+export async function getHealth(req: Request, res: Response, next: NextFunction): Promise<void> {
+  try {
+    sendSuccess(res, {
+      status: 'healthy',
+      timestamp: new Date().toISOString(),
+      uptime: process.uptime(),
+    }, 'Service is healthy');
+  } catch (error) {
+    next(error);
+  }
+}`
+    : `const { sendSuccess } = require('../utils/response');
+
+async function getHealth(req, res, next) {
+  try {
+    sendSuccess(res, {
+      status: 'healthy',
+      timestamp: new Date().toISOString(),
+      uptime: process.uptime(),
+    }, 'Service is healthy');
+  } catch (error) {
+    next(error);
+  }
+}
+
+module.exports = { getHealth };`;
+
+  await fs.writeFile(path.join(controllersPath, `health.controller.${ext}`), healthController);
+}
+
+async function generateRoutes(routesPath, config, ext, isTS) {
+  const indexRoutes = isTS
+    ? `import { Router } from 'express';
+import healthRoutes from './health.routes';
+
+const router = Router();
+
+router.use('/health', healthRoutes);
+
+export default router;`
+    : `const express = require('express');
+const healthRoutes = require('./health.routes');
+
+const router = express.Router();
+
+router.use('/health', healthRoutes);
+
+module.exports = router;`;
+
+  await fs.writeFile(path.join(routesPath, `index.${ext}`), indexRoutes);
+
+  const healthRoutes = isTS
+    ? `import { Router } from 'express';
+import { getHealth } from '../controllers/health.controller';
+
+const router = Router();
+
+/**
+ * @swagger
+ * /api/health:
+ *   get:
+ *     summary: Check API health
+ *     tags: [Health]
+ *     responses:
+ *       200:
+ *         description: API is healthy
+ */
+router.get('/', getHealth);
+
+export default router;`
+    : `const express = require('express');
+const { getHealth } = require('../controllers/health.controller');
+
+const router = express.Router();
+
+/**
+ * @swagger
+ * /api/health:
+ *   get:
+ *     summary: Check API health
+ *     tags: [Health]
+ *     responses:
+ *       200:
+ *         description: API is healthy
+ */
+router.get('/', getHealth);
+
+module.exports = router;`;
+
+  await fs.writeFile(path.join(routesPath, `health.routes.${ext}`), healthRoutes);
+}
+
+async function generateModels(modelsPath, config, ext, isTS) {
+  // Generate example model based on database type
+  if (config.database === 'mongodb') {
+    const userModel = isTS
+      ? `import mongoose, { Schema, Document } from 'mongoose';
+
+export interface IUser extends Document {
+  username: string;
+  email: string;
+  password: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+const userSchema = new Schema<IUser>(
+  {
+    username: { type: String, required: true, unique: true },
+    email: { type: String, required: true, unique: true },
+    password: { type: String, required: true },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+export default mongoose.model<IUser>('User', userSchema);`
+      : `const mongoose = require('mongoose');
+
+const userSchema = new mongoose.Schema(
+  {
+    username: { type: String, required: true, unique: true },
+    email: { type: String, required: true, unique: true },
+    password: { type: String, required: true },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+module.exports = mongoose.model('User', userSchema);`;
+
+    await fs.writeFile(path.join(modelsPath, `user.model.${ext}`), userModel);
+  } else if (config.database === 'postgresql') {
+    const userModel = isTS
+      ? `import { pool } from '../config/database';
+
+export interface IUser {
+  id?: number;
+  username: string;
+  email: string;
+  password: string;
+  created_at?: Date;
+  updated_at?: Date;
+}
+
+export class User {
+  static async findById(id: number): Promise<IUser | null> {
+    const result = await pool.query('SELECT * FROM users WHERE id = $1', [id]);
+    return result.rows[0] || null;
+  }
+
+  static async findByEmail(email: string): Promise<IUser | null> {
+    const result = await pool.query('SELECT * FROM users WHERE email = $1', [email]);
+    return result.rows[0] || null;
+  }
+
+  static async create(user: IUser): Promise<IUser> {
+    const result = await pool.query(
+      'INSERT INTO users (username, email, password) VALUES ($1, $2, $3) RETURNING *',
+      [user.username, user.email, user.password]
+    );
+    return result.rows[0];
+  }
+
+  static async update(id: number, updates: Partial<IUser>): Promise<IUser | null> {
+    const fields = Object.keys(updates);
+    const values = Object.values(updates);
+    const setClause = fields.map((field, i) => \`\${field} = $\${i + 2}\`).join(', ');
+    
+    const result = await pool.query(
+      \`UPDATE users SET \${setClause}, updated_at = NOW() WHERE id = $1 RETURNING *\`,
+      [id, ...values]
+    );
+    return result.rows[0] || null;
+  }
+
+  static async delete(id: number): Promise<boolean> {
+    const result = await pool.query('DELETE FROM users WHERE id = $1', [id]);
+    return result.rowCount! > 0;
+  }
+}`
+      : `const { pool } = require('../config/database');
+
+class User {
+  static async findById(id) {
+    const result = await pool.query('SELECT * FROM users WHERE id = $1', [id]);
+    return result.rows[0] || null;
+  }
+
+  static async findByEmail(email) {
+    const result = await pool.query('SELECT * FROM users WHERE email = $1', [email]);
+    return result.rows[0] || null;
+  }
+
+  static async create(user) {
+    const result = await pool.query(
+      'INSERT INTO users (username, email, password) VALUES ($1, $2, $3) RETURNING *',
+      [user.username, user.email, user.password]
+    );
+    return result.rows[0];
+  }
+
+  static async update(id, updates) {
+    const fields = Object.keys(updates);
+    const values = Object.values(updates);
+    const setClause = fields.map((field, i) => \`\${field} = $\${i + 2}\`).join(', ');
+    
+    const result = await pool.query(
+      \`UPDATE users SET \${setClause}, updated_at = NOW() WHERE id = $1 RETURNING *\`,
+      [id, ...values]
+    );
+    return result.rows[0] || null;
+  }
+
+  static async delete(id) {
+    const result = await pool.query('DELETE FROM users WHERE id = $1', [id]);
+    return result.rowCount > 0;
+  }
+}
+
+module.exports = User;`;
+
+    await fs.writeFile(path.join(modelsPath, `user.model.${ext}`), userModel);
+  }
+}
+
+async function generateServices(servicesPath, config, ext, isTS) {
+  // Generate a placeholder service file
+  const exampleService = isTS
+    ? `${config.features.includes('logging') ? "import logger from '../config/logger';" : ''}
+
+export class ExampleService {
+  static async performAction(data: any): Promise<any> {
+    ${config.features.includes('logging') ? "logger.info('Performing action with data:', data);" : "console.log('Performing action with data:', data);"}
+    // Add your business logic here
+    return { success: true, data };
+  }
+}`
+    : `${config.features.includes('logging') ? "const logger = require('../config/logger');" : ''}
+
+class ExampleService {
+  static async performAction(data) {
+    ${config.features.includes('logging') ? "logger.info('Performing action with data:', data);" : "console.log('Performing action with data:', data);"}
+    // Add your business logic here
+    return { success: true, data };
+  }
+}
+
+module.exports = ExampleService;`;
+
+  await fs.writeFile(path.join(servicesPath, `example.service.${ext}`), exampleService);
+}
+
+module.exports = { generateMVCStructure };