express-genix 1.1.0

package/templates/middleware/validation.js.ejs

@@ -0,0 +1,48 @@
+// templates/middleware/validation.js.ejs
+const { AppError } = require('../utils/errors');
+
+const validateEmail = (email) => {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(email);
+};
+
+const validateLogin = (req, res, next) => {
+  const { email, password } = req.body;
+  
+  if (!email || !password) {
+    return next(new AppError('Email and password are required', 400));
+  }
+  
+  if (!validateEmail(email)) {
+    return next(new AppError('Please provide a valid email address', 400));
+  }
+  
+  next();
+};
+
+const validateRegister = (req, res, next) => {
+  const { username, email, password } = req.body;
+  
+  if (!username || !email || !password) {
+    return next(new AppError('Username, email, and password are required', 400));
+  }
+  
+  if (username.length < 3 || username.length > 50) {
+    return next(new AppError('Username must be between 3 and 50 characters', 400));
+  }
+  
+  if (!validateEmail(email)) {
+    return next(new AppError('Please provide a valid email address', 400));
+  }
+  
+  if (password.length < 6) {
+    return next(new AppError('Password must be at least 6 characters long', 400));
+  }
+  
+  next();
+};
+
+module.exports = {
+  validateLogin,
+  validateRegister,
+};

package/templates/models/User.mongo.js.ejs

@@ -0,0 +1,33 @@
+const mongoose = require('mongoose');
+
+const userSchema = new mongoose.Schema({
+  username: {
+    type: String,
+    required: [true, 'Username is required'],
+    unique: true,
+    trim: true,
+    minlength: [3, 'Username must be at least 3 characters long'],
+    maxlength: [50, 'Username must not exceed 50 characters'],
+  },
+  email: {
+    type: String,
+    required: [true, 'Email is required'],
+    unique: true,
+    lowercase: true,
+    trim: true,
+    match: [/^\S+@\S+\.\S+$/, 'Please enter a valid email address'],
+  },
+  password: {
+    type: String,
+    required: [true, 'Password is required'],
+    minlength: [6, 'Password must be at least 6 characters long'],
+  },
+}, {
+  timestamps: true,
+});
+
+// Index for better query performance
+userSchema.index({ email: 1 });
+userSchema.index({ username: 1 });
+
+module.exports = mongoose.model('User', userSchema);

package/templates/models/User.postgres.js.ejs

@@ -0,0 +1,41 @@
+const { DataTypes } = require('sequelize');
+const { sequelize } = require('../config/database');
+
+const User = sequelize.define('User', {
+  id: {
+    type: DataTypes.UUID,
+    defaultValue: DataTypes.UUIDV4,
+    primaryKey: true,
+  },
+  username: {
+    type: DataTypes.STRING(50),
+    allowNull: false,
+    unique: true,
+    validate: {
+      len: [3, 50],
+      notEmpty: true,
+    },
+  },
+  email: {
+    type: DataTypes.STRING,
+    allowNull: false,
+    unique: true,
+    validate: {
+      isEmail: true,
+      notEmpty: true,
+    },
+  },
+  password: {
+    type: DataTypes.STRING,
+    allowNull: false,
+    validate: {
+      len: [6, 255],
+      notEmpty: true,
+    },
+  },
+}, {
+  timestamps: true,
+  tableName: 'users',
+});
+
+module.exports = User;

package/templates/models/index.mongo.js.ejs

@@ -0,0 +1,8 @@
+// For MongoDB, we typically don't need an index file as we import models directly
+// But you can use this file to define model relationships if needed
+
+const User = require('./User');
+
+module.exports = {
+  User,
+};

package/templates/models/index.postgres.js.ejs

@@ -0,0 +1,12 @@
+const { sequelize } = require('../config/database');
+const User = require('./User');
+
+// Define associations here if you have multiple models
+// Example:
+// User.hasMany(Post);
+// Post.belongsTo(User);
+
+module.exports = {
+  sequelize,
+  User,
+};

package/templates/routes/authRoutes.js.ejs

@@ -0,0 +1,14 @@
+// templates/routes/authRoutes.js.ejs
+const express = require('express');
+const authController = require('../controllers/authController');
+const { validateLogin, validateRegister } = require('../middleware/validation');
+
+const router = express.Router();
+
+// Authentication routes
+router.post('/register', validateRegister, authController.register);
+router.post('/login', validateLogin, authController.login);
+router.post('/refresh', authController.refreshToken);
+router.post('/logout', authController.authenticateToken, authController.logout);
+
+module.exports = router;

package/templates/routes/exampleRoutes.js.ejs

@@ -0,0 +1,13 @@
+const express = require('express');
+const exampleController = require('../controllers/exampleController');
+
+const router = express.Router();
+
+// Example routes
+router.get('/', exampleController.getAllExamples);
+router.get('/:id', exampleController.getExampleById);
+router.post('/', exampleController.createExample);
+router.put('/:id', exampleController.updateExample);
+router.delete('/:id', exampleController.deleteExample);
+
+module.exports = router;

package/templates/routes/index.js.ejs

@@ -0,0 +1,24 @@
+const express = require('express');<% if (hasDatabase) { %>
+    const authRoutes = require('./authRoutes');
+    const userRoutes = require('./userRoutes');<% } else { %>
+    const exampleRoutes = require('./exampleRoutes');<% } %>
+    
+    const router = express.Router();
+    
+    // Mount route modules<% if (hasDatabase) { %>
+    router.use('/auth', authRoutes);
+    router.use('/users', userRoutes);<% } else { %>
+    router.use('/examples', exampleRoutes);<% } %>
+    
+    // API root endpoint
+    router.get('/', (req, res) => {
+      res.json({
+        message: 'Welcome to the API',
+        version: '1.0.0',
+        documentation: '/api-docs',<% if (hasDatabase) { %>
+        features: ['authentication', 'user-management', '<%= db %>-database']<% } else { %>
+        features: ['rate-limiting', 'logging', 'swagger-docs']<% } %>,
+      });
+    });
+    
+    module.exports = router;

package/templates/routes/userRoutes.js.ejs

@@ -0,0 +1,16 @@
+// templates/routes/userRoutes.js.ejs
+const express = require('express');
+const userController = require('../controllers/userController');
+const authController = require('../controllers/authController');
+
+const router = express.Router();
+
+// All user routes require authentication
+router.use(authController.authenticateToken);
+
+// User routes
+router.get('/profile', userController.getProfile);
+router.put('/profile', userController.updateProfile);
+router.delete('/profile', userController.deleteProfile);
+
+module.exports = router;

package/templates/services/authService.js.ejs

@@ -0,0 +1,36 @@
+const jwt = require('jsonwebtoken');
+
+const jwtSecret = process.env.JWT_SECRET || 'your-secret-key';
+const jwtRefreshSecret = process.env.JWT_REFRESH_SECRET || 'your-refresh-secret-key';
+
+const generateTokens = (user) => {
+  const payload = {
+    userId: user.id,
+    username: user.username,
+    email: user.email,
+  };
+  
+  const accessToken = jwt.sign(payload, jwtSecret, {
+    expiresIn: process.env.JWT_EXPIRE || '15m',
+  });
+  
+  const refreshToken = jwt.sign({ userId: user.id }, jwtRefreshSecret, {
+    expiresIn: process.env.JWT_REFRESH_EXPIRE || '7d',
+  });
+  
+  return { accessToken, refreshToken };
+};
+
+const verifyToken = (token) => {
+  return jwt.verify(token, jwtSecret);
+};
+
+const verifyRefreshToken = (token) => {
+  return jwt.verify(token, jwtRefreshSecret);
+};
+
+module.exports = {
+  generateTokens,
+  verifyToken,
+  verifyRefreshToken,
+};

package/templates/services/exampleService.js.ejs

@@ -0,0 +1,113 @@
+const { createLogger } = require('../utils/logger');
+
+const logger = createLogger('ExampleService');
+
+// In-memory storage for examples (replace with database in real applications)
+let examples = [
+  {
+    id: '1',
+    title: 'Example 1',
+    description: 'This is the first example',
+    createdAt: new Date('2024-01-01'),
+    updatedAt: new Date('2024-01-01'),
+  },
+  {
+    id: '2',
+    title: 'Example 2',
+    description: 'This is the second example',
+    createdAt: new Date('2024-01-02'),
+    updatedAt: new Date('2024-01-02'),
+  },
+];
+
+let nextId = 3;
+
+/**
+ * Get all examples with pagination
+ */
+const getAllExamples = async (page = 1, limit = 10) => {
+  logger.info('Fetching all examples', { page, limit });
+  
+  const startIndex = (page - 1) * limit;
+  const endIndex = startIndex + limit;
+  
+  const paginatedExamples = examples.slice(startIndex, endIndex);
+  
+  return {
+    examples: paginatedExamples,
+    total: examples.length,
+    totalPages: Math.ceil(examples.length / limit),
+    currentPage: page,
+  };
+};
+
+/**
+ * Get example by ID
+ */
+const getExampleById = async (id) => {
+  logger.info('Fetching example by ID', { id });
+  
+  const example = examples.find(ex => ex.id === id);
+  return example || null;
+};
+
+/**
+ * Create new example
+ */
+const createExample = async (exampleData) => {
+  logger.info('Creating new example', { title: exampleData.title });
+  
+  const newExample = {
+    id: nextId.toString(),
+    ...exampleData,
+  };
+  
+  examples.push(newExample);
+  nextId++;
+  
+  return newExample;
+};
+
+/**
+ * Update example by ID
+ */
+const updateExample = async (id, updateData) => {
+  logger.info('Updating example', { id });
+  
+  const index = examples.findIndex(ex => ex.id === id);
+  
+  if (index === -1) {
+    return null;
+  }
+  
+  examples[index] = {
+    ...examples[index],
+    ...updateData,
+  };
+  
+  return examples[index];
+};
+
+/**
+ * Delete example by ID
+ */
+const deleteExample = async (id) => {
+  logger.info('Deleting example', { id });
+  
+  const index = examples.findIndex(ex => ex.id === id);
+  
+  if (index === -1) {
+    return false;
+  }
+  
+  examples.splice(index, 1);
+  return true;
+};
+
+module.exports = {
+  getAllExamples,
+  getExampleById,
+  createExample,
+  updateExample,
+  deleteExample,
+};

package/templates/services/userService.mongo.js.ejs

@@ -0,0 +1,34 @@
+// templates/services/userService.mongo.js.ejs
+const User = require('../models/User');
+
+const findById = async (id) => {
+  return await User.findById(id).select('-password');
+};
+
+const findByEmail = async (email) => {
+  return await User.findOne({ email });
+};
+
+const create = async (userData) => {
+  const user = new User(userData);
+  return await user.save();
+};
+
+const updateById = async (id, updateData) => {
+  return await User.findByIdAndUpdate(id, updateData, { 
+    new: true, 
+    select: '-password' 
+  });
+};
+
+const deleteById = async (id) => {
+  return await User.findByIdAndDelete(id);
+};
+
+module.exports = {
+  findById,
+  findByEmail,
+  create,
+  updateById,
+  deleteById,
+};

package/templates/services/userService.postgres.js.ejs

@@ -0,0 +1,31 @@
+// templates/services/userService.postgres.js.ejs
+const { User } = require('../models');
+
+const findById = async (id) => {
+  return await User.findByPk(id, { attributes: { exclude: ['password'] } });
+};
+
+const findByEmail = async (email) => {
+  return await User.findOne({ where: { email } });
+};
+
+const create = async (userData) => {
+  return await User.create(userData);
+};
+
+const updateById = async (id, updateData) => {
+  await User.update(updateData, { where: { id } });
+  return await User.findByPk(id, { attributes: { exclude: ['password'] } });
+};
+
+const deleteById = async (id) => {
+  return await User.destroy({ where: { id } });
+};
+
+module.exports = {
+  findById,
+  findByEmail,
+  create,
+  updateById,
+  deleteById,
+};

package/templates/tests/auth.test.js.ejs

@@ -0,0 +1,67 @@
+// templates/tests/auth.test.js.ejs
+const request = require('supertest');
+const app = require('../src/app');
+
+describe('Authentication Endpoints', () => {
+  describe('POST /api/auth/register', () => {
+    it('should register a new user', async () => {
+      const userData = {
+        username: 'testuser',
+        email: 'test@example.com',
+        password: 'password123',
+      };
+
+      const res = await request(app)
+        .post('/api/auth/register')
+        .send(userData);
+
+      expect(res.statusCode).toBe(201);
+      expect(res.body).toHaveProperty('accessToken');
+      expect(res.body).toHaveProperty('refreshToken');
+      expect(res.body.user).toHaveProperty('email', userData.email);
+    });
+
+    it('should return 400 for invalid email', async () => {
+      const userData = {
+        username: 'testuser',
+        email: 'invalid-email',
+        password: 'password123',
+      };
+
+      const res = await request(app)
+        .post('/api/auth/register')
+        .send(userData);
+
+      expect(res.statusCode).toBe(400);
+    });
+  });
+
+  describe('POST /api/auth/login', () => {
+    it('should login with valid credentials', async () => {
+      const credentials = {
+        email: 'test@example.com',
+        password: 'password123',
+      };
+
+      const res = await request(app)
+        .post('/api/auth/login')
+        .send(credentials);
+
+      expect(res.statusCode).toBe(200);
+      expect(res.body).toHaveProperty('accessToken');
+    });
+
+    it('should return 401 for invalid credentials', async () => {
+      const credentials = {
+        email: 'test@example.com',
+        password: 'wrongpassword',
+      };
+
+      const res = await request(app)
+        .post('/api/auth/login')
+        .send(credentials);
+
+      expect(res.statusCode).toBe(401);
+    });
+  });
+});

package/templates/tests/example.test.js.ejs

@@ -0,0 +1,113 @@
+const request = require('supertest');
+const app = require('../src/app');
+
+describe('Example Endpoints', () => {
+  describe('GET /api/examples', () => {
+    it('should get all examples', async () => {
+      const res = await request(app)
+        .get('/api/examples');
+
+      expect(res.statusCode).toBe(200);
+      expect(res.body.success).toBe(true);
+      expect(res.body.data).toHaveProperty('examples');
+      expect(Array.isArray(res.body.data.examples)).toBe(true);
+    });
+
+    it('should support pagination', async () => {
+      const res = await request(app)
+        .get('/api/examples?page=1&limit=1');
+
+      expect(res.statusCode).toBe(200);
+      expect(res.body.pagination).toEqual({
+        page: 1,
+        limit: 1,
+      });
+    });
+  });
+
+  describe('GET /api/examples/:id', () => {
+    it('should get example by id', async () => {
+      const res = await request(app)
+        .get('/api/examples/1');
+
+      expect(res.statusCode).toBe(200);
+      expect(res.body.success).toBe(true);
+      expect(res.body.data).toHaveProperty('id', '1');
+    });
+
+    it('should return 404 for non-existent example', async () => {
+      const res = await request(app)
+        .get('/api/examples/999');
+
+      expect(res.statusCode).toBe(404);
+    });
+  });
+
+  describe('POST /api/examples', () => {
+    it('should create new example', async () => {
+      const exampleData = {
+        title: 'Test Example',
+        description: 'This is a test example',
+      };
+
+      const res = await request(app)
+        .post('/api/examples')
+        .send(exampleData);
+
+      expect(res.statusCode).toBe(201);
+      expect(res.body.success).toBe(true);
+      expect(res.body.data).toHaveProperty('title', exampleData.title);
+      expect(res.body.data).toHaveProperty('description', exampleData.description);
+    });
+
+    it('should return 400 for missing required fields', async () => {
+      const res = await request(app)
+        .post('/api/examples')
+        .send({ title: 'Only title' });
+
+      expect(res.statusCode).toBe(400);
+    });
+  });
+
+  describe('PUT /api/examples/:id', () => {
+    it('should update existing example', async () => {
+      const updateData = {
+        title: 'Updated Example',
+        description: 'Updated description',
+      };
+
+      const res = await request(app)
+        .put('/api/examples/1')
+        .send(updateData);
+
+      expect(res.statusCode).toBe(200);
+      expect(res.body.success).toBe(true);
+      expect(res.body.data).toHaveProperty('title', updateData.title);
+    });
+
+    it('should return 404 for non-existent example', async () => {
+      const res = await request(app)
+        .put('/api/examples/999')
+        .send({ title: 'Updated' });
+
+      expect(res.statusCode).toBe(404);
+    });
+  });
+
+  describe('DELETE /api/examples/:id', () => {
+    it('should delete existing example', async () => {
+      const res = await request(app)
+        .delete('/api/examples/2');
+
+      expect(res.statusCode).toBe(200);
+      expect(res.body.success).toBe(true);
+    });
+
+    it('should return 404 for non-existent example', async () => {
+      const res = await request(app)
+        .delete('/api/examples/999');
+
+      expect(res.statusCode).toBe(404);
+    });
+  });
+});

package/templates/tests/setup.js.ejs

@@ -0,0 +1,12 @@
+// templates/tests/setup.js.ejs
+// Global test setup
+process.env.NODE_ENV = 'test';
+<% if (hasDatabase) { %>process.env.JWT_SECRET = 'test-secret';
+process.env.JWT_REFRESH_SECRET = 'test-refresh-secret';<% } %>
+
+// Suppress console logs during tests
+if (process.env.NODE_ENV === 'test') {
+  console.log = jest.fn();
+  console.error = jest.fn();
+  console.warn = jest.fn();
+}

package/templates/tests/users.test.js.ejs

@@ -0,0 +1,43 @@
+// templates/tests/users.test.js.ejs
+const request = require('supertest');
+const jwt = require('jsonwebtoken');
+const app = require('../src/app');
+
+describe('User Endpoints', () => {
+  let authToken;
+
+  beforeAll(() => {
+    // Create a test token
+    authToken = jwt.sign(
+      { userId: 'test-user-id', username: 'testuser', email: 'test@example.com' },
+      process.env.JWT_SECRET,
+      { expiresIn: '1h' }
+    );
+  });
+
+  describe('GET /api/users/profile', () => {
+    it('should get user profile with valid token', async () => {
+      const res = await request(app)
+        .get('/api/users/profile')
+        .set('Authorization', `Bearer ${authToken}`);
+
+      expect(res.statusCode).toBe(200);
+      expect(res.body).toHaveProperty('user');
+    });
+
+    it('should return 401 without token', async () => {
+      const res = await request(app)
+        .get('/api/users/profile');
+
+      expect(res.statusCode).toBe(401);
+    });
+
+    it('should return 403 with invalid token', async () => {
+      const res = await request(app)
+        .get('/api/users/profile')
+        .set('Authorization', 'Bearer invalid-token');
+
+      expect(res.statusCode).toBe(403);
+    });
+  });
+});

package/templates/utils/errors.js.ejs

@@ -0,0 +1,13 @@
+// templates/utils/errors.js.ejs
+class AppError extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.status = `${statusCode}`.startsWith('4') ? 'fail' : 'error';
+    this.isOperational = true;
+
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+module.exports = { AppError };