express-genix 1.1.4 → 2.0.0

package/templates/routes/userRoutes.js.ejs

@@ -1,16 +1,79 @@
-// 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);
-
+const express = require('express');
+const userController = require('../controllers/userController');
+const { authenticateToken } = require('../middleware/auth');
+
+const router = express.Router();
+
+/**
+ * @swagger
+ * /users/profile:
+ *   get:
+ *     summary: Get user profile
+ *     tags: [Users]
+ *     security:
+ *       - bearerAuth: []
+ *     responses:
+ *       200:
+ *         description: User profile retrieved
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                 data:
+ *                   type: object
+ *                   properties:
+ *                     user:
+ *                       type: object
+ *                       properties:
+ *                         id:
+ *                           type: string
+ *                         username:
+ *                           type: string
+ *                         email:
+ *                           type: string
+ *                         createdAt:
+ *                           type: string
+ *                           format: date-time
+ *       401:
+ *         description: Unauthorized — provide a Bearer token from login
+ *   put:
+ *     summary: Update user profile
+ *     tags: [Users]
+ *     security:
+ *       - bearerAuth: []
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             properties:
+ *               username:
+ *                 type: string
+ *                 example: newusername
+ *     responses:
+ *       200:
+ *         description: Profile updated
+ *       401:
+ *         description: Unauthorized
+ *   delete:
+ *     summary: Delete user profile
+ *     tags: [Users]
+ *     security:
+ *       - bearerAuth: []
+ *     responses:
+ *       200:
+ *         description: Profile deleted
+ *       401:
+ *         description: Unauthorized
+ */
+router.use(authenticateToken);
+
+router.get('/profile', userController.getProfile);
+router.put('/profile', userController.updateProfile);
+router.delete('/profile', userController.deleteProfile);
+
 module.exports = router;

package/templates/services/authService.js.ejs

@@ -1,36 +1,112 @@
-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,
+const jwt = require('jsonwebtoken');
+const crypto = require('crypto');
+<% if (hasRedis) { %>const { redis } = require('../config/redis');
+<% } %>
+<% if (!hasRedis) { %>
+// In-memory token blacklist — replace with Redis for production.
+const tokenBlacklist = new Set();
+const resetTokens = new Map(); // token → { email, expiresAt }
+<% } %>
+const generateTokens = (user) => {
+  const payload = {
+    userId: user.id,
+    username: user.username,
+    email: user.email,
+  };
+
+  const accessToken = jwt.sign(payload, process.env.JWT_SECRET, {
+    expiresIn: process.env.JWT_EXPIRE || '15m',
+  });
+
+  const refreshToken = jwt.sign({ userId: user.id }, process.env.JWT_REFRESH_SECRET, {
+    expiresIn: process.env.JWT_REFRESH_EXPIRE || '7d',
+  });
+
+  return { accessToken, refreshToken };
+};
+
+const verifyToken = (token) => jwt.verify(token, process.env.JWT_SECRET);
+
+const verifyRefreshToken = (token) => jwt.verify(token, process.env.JWT_REFRESH_SECRET);
+<% if (hasRedis) { %>
+const blacklistToken = async (token) => {
+  const decoded = jwt.decode(token);
+  const ttl = decoded && decoded.exp ? decoded.exp - Math.floor(Date.now() / 1000) : 86400;
+  if (ttl > 0) {
+    await redis.set(`bl:${token}`, '1', 'EX', ttl);
+  }
+};
+
+const isTokenBlacklisted = async (token) => {
+  const result = await redis.get(`bl:${token}`);
+  return result !== null;
+};
+
+const generateResetToken = async (email) => {
+  const token = crypto.randomBytes(32).toString('hex');
+  const hash = crypto.createHash('sha256').update(token).digest('hex');
+  await redis.set(`reset:${hash}`, email, 'EX', 3600); // 1 hour
+  return token;
+};
+
+const verifyResetToken = async (token) => {
+  const hash = crypto.createHash('sha256').update(token).digest('hex');
+  const email = await redis.get(`reset:${hash}`);
+  return email;
+};
+
+const consumeResetToken = async (token) => {
+  const hash = crypto.createHash('sha256').update(token).digest('hex');
+  const email = await redis.get(`reset:${hash}`);
+  if (email) {
+    await redis.del(`reset:${hash}`);
+  }
+  return email;
+};
+<% } else { %>
+const blacklistToken = (token) => {
+  tokenBlacklist.add(token);
+};
+
+const isTokenBlacklisted = (token) => {
+  return tokenBlacklist.has(token);
+};
+
+const generateResetToken = (email) => {
+  const token = crypto.randomBytes(32).toString('hex');
+  const hash = crypto.createHash('sha256').update(token).digest('hex');
+  resetTokens.set(hash, { email, expiresAt: Date.now() + 3600000 }); // 1 hour
+  return token;
+};
+
+const verifyResetToken = (token) => {
+  const hash = crypto.createHash('sha256').update(token).digest('hex');
+  const entry = resetTokens.get(hash);
+  if (!entry || entry.expiresAt < Date.now()) {
+    resetTokens.delete(hash);
+    return null;
+  }
+  return entry.email;
+};
+
+const consumeResetToken = (token) => {
+  const hash = crypto.createHash('sha256').update(token).digest('hex');
+  const entry = resetTokens.get(hash);
+  if (!entry || entry.expiresAt < Date.now()) {
+    resetTokens.delete(hash);
+    return null;
+  }
+  resetTokens.delete(hash);
+  return entry.email;
+};
+<% } %>
+module.exports = {
+  generateTokens,
+  verifyToken,
+  verifyRefreshToken,
+  blacklistToken,
+  isTokenBlacklisted,
+  generateResetToken,
+  verifyResetToken,
+  consumeResetToken,
 };

package/templates/services/exampleService.js.ejs

@@ -1,113 +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,
+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.mongodb.js.ejs

@@ -1,34 +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,
+// 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

@@ -1,31 +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,
+// 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/services/userService.prisma.js.ejs

@@ -0,0 +1,36 @@
+const { prisma } = require('../config/database');
+
+const findById = async (id) => {
+  return await prisma.user.findUnique({
+    where: { id },
+    select: { id: true, username: true, email: true, createdAt: true, updatedAt: true },
+  });
+};
+
+const findByEmail = async (email) => {
+  return await prisma.user.findUnique({ where: { email } });
+};
+
+const create = async (userData) => {
+  return await prisma.user.create({ data: userData });
+};
+
+const updateById = async (id, updateData) => {
+  return await prisma.user.update({
+    where: { id },
+    data: updateData,
+    select: { id: true, username: true, email: true, createdAt: true, updatedAt: true },
+  });
+};
+
+const deleteById = async (id) => {
+  return await prisma.user.delete({ where: { id } });
+};
+
+module.exports = {
+  findById,
+  findByEmail,
+  create,
+  updateById,
+  deleteById,
+};