express-genix 2.0.1 → 3.0.0

package/templates/routes/uploadRoutes.js.ejs

@@ -0,0 +1,100 @@
+const express = require('express');
+const path = require('path');
+const fs = require('fs');
+const { uploadImage, uploadAny } = require('../middleware/upload');
+const { success } = require('../utils/response');
+const { AppError } = require('../utils/errors');
+<% if (hasAuth) { %>const { authenticateToken } = require('../middleware/auth');<% } %>
+
+const router = express.Router();
+
+/**
+ * @swagger
+ * /uploads/single:
+ *   post:
+ *     summary: Upload a single image
+ *     tags: [Uploads]<% if (hasAuth) { %>
+ *     security:
+ *       - bearerAuth: []<% } %>
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         multipart/form-data:
+ *           schema:
+ *             type: object
+ *             properties:
+ *               file:
+ *                 type: string
+ *                 format: binary
+ *     responses:
+ *       200:
+ *         description: File uploaded
+ *       400:
+ *         description: Invalid file
+ */
+router.post('/single',
+  <% if (hasAuth) { %>authenticateToken,<% } %>
+  uploadImage.single('file'),
+  (req, res) => {
+    if (!req.file) {
+      throw new AppError('No file uploaded', 400);
+    }
+
+    return success(res, {
+      message: 'File uploaded successfully',
+      file: {
+        filename: req.file.filename,
+        originalName: req.file.originalname,
+        size: req.file.size,
+        mimetype: req.file.mimetype,
+        path: `/uploads/${req.file.filename}`,
+      },
+    });
+  }
+);
+
+/**
+ * @swagger
+ * /uploads/multiple:
+ *   post:
+ *     summary: Upload multiple files (max 5)
+ *     tags: [Uploads]<% if (hasAuth) { %>
+ *     security:
+ *       - bearerAuth: []<% } %>
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         multipart/form-data:
+ *           schema:
+ *             type: object
+ *             properties:
+ *               files:
+ *                 type: array
+ *                 items:
+ *                   type: string
+ *                   format: binary
+ *     responses:
+ *       200:
+ *         description: Files uploaded
+ */
+router.post('/multiple',
+  <% if (hasAuth) { %>authenticateToken,<% } %>
+  uploadAny.array('files', 5),
+  (req, res) => {
+    if (!req.files || req.files.length === 0) {
+      throw new AppError('No files uploaded', 400);
+    }
+
+    const files = req.files.map((file) => ({
+      filename: file.filename,
+      originalName: file.originalname,
+      size: file.size,
+      mimetype: file.mimetype,
+      path: `/uploads/${file.filename}`,
+    }));
+
+    return success(res, { message: `${files.length} file(s) uploaded`, files });
+  }
+);
+
+module.exports = router;

package/templates/services/authService.js.ejs

@@ -12,6 +12,7 @@ const generateTokens = (user) => {
     userId: user.id,
     username: user.username,
     email: user.email,
+    role: user.role || 'user',
   };
 
   const accessToken = jwt.sign(payload, process.env.JWT_SECRET, {

package/templates/services/emailService.js.ejs

@@ -0,0 +1,88 @@
+const nodemailer = require('nodemailer');
+const logger = require('../utils/logger');
+
+let transporter;
+
+const getTransporter = () => {
+  if (transporter) return transporter;
+
+  if (process.env.NODE_ENV === 'production') {
+    transporter = nodemailer.createTransport({
+      host: process.env.SMTP_HOST,
+      port: parseInt(process.env.SMTP_PORT, 10) || 587,
+      secure: process.env.SMTP_SECURE === 'true',
+      auth: {
+        user: process.env.SMTP_USER,
+        pass: process.env.SMTP_PASS,
+      },
+    });
+  } else {
+    // Use Ethereal for development (fake SMTP)
+    transporter = nodemailer.createTransport({
+      host: 'smtp.ethereal.email',
+      port: 587,
+      auth: {
+        user: process.env.SMTP_USER || '',
+        pass: process.env.SMTP_PASS || '',
+      },
+    });
+  }
+
+  return transporter;
+};
+
+const sendMail = async ({ to, subject, html, text }) => {
+  try {
+    const transport = getTransporter();
+    const info = await transport.sendMail({
+      from: process.env.SMTP_FROM || '"App" <noreply@example.com>',
+      to,
+      subject,
+      html,
+      text: text || subject,
+    });
+
+    logger.info(`Email sent: ${info.messageId}`);
+
+    if (process.env.NODE_ENV !== 'production') {
+      const previewUrl = nodemailer.getTestMessageUrl(info);
+      if (previewUrl) {
+        logger.info(`Preview URL: ${previewUrl}`);
+      }
+    }
+
+    return info;
+  } catch (error) {
+    logger.error('Failed to send email:', error);
+    throw error;
+  }
+};
+
+const sendWelcomeEmail = async (email, username) => {
+  return sendMail({
+    to: email,
+    subject: 'Welcome!',
+    html: `
+      <h1>Welcome, ${username}!</h1>
+      <p>Thank you for creating an account. We're glad to have you.</p>
+    `,
+  });
+};
+
+const sendPasswordResetEmail = async (email, resetToken) => {
+  const resetUrl = `${process.env.FRONTEND_URL || 'http://localhost:3000'}/reset-password?token=${resetToken}`;
+
+  return sendMail({
+    to: email,
+    subject: 'Password Reset Request',
+    html: `
+      <h1>Password Reset</h1>
+      <p>You requested a password reset. Click the link below to set a new password:</p>
+      <p><a href="${resetUrl}">Reset Password</a></p>
+      <p>This link expires in 1 hour.</p>
+      <p>If you did not request this, please ignore this email.</p>
+    `,
+  });
+};
+
+module.exports = { sendMail, sendWelcomeEmail, sendPasswordResetEmail, getTransporter };

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

@@ -22,7 +22,34 @@ const updateById = async (id, updateData) => {
 };
 
 const deleteById = async (id) => {
-  return await User.findByIdAndDelete(id);
+<% if (hasSoftDelete) { %>  const user = await User.findById(id);
+  if (user) return user.softDelete();
+  return null;
+<% } else { %>  return await User.findByIdAndDelete(id);
+<% } %>};
+<% if (hasSoftDelete) { %>
+const restoreById = async (id) => {
+  const user = await User.findOne({ _id: id, includeDeleted: true });
+  if (user) return user.restore();
+  return null;
+};
+
+const findDeleted = async ({ page = 1, limit = 20 } = {}) => {
+  const skip = (page - 1) * limit;
+  const [users, total] = await Promise.all([
+    User.find({ deletedAt: { $ne: null }, includeDeleted: true }).select('-password').skip(skip).limit(limit),
+    User.countDocuments({ deletedAt: { $ne: null } }),
+  ]);
+  return { users, total, page, totalPages: Math.ceil(total / limit) };
+};
+<% } %>
+const findAll = async ({ page = 1, limit = 20 } = {}) => {
+  const skip = (page - 1) * limit;
+  const [users, total] = await Promise.all([
+    User.find().select('-password').skip(skip).limit(limit).sort({ createdAt: -1 }),
+    User.countDocuments(),
+  ]);
+  return { users, total, page, totalPages: Math.ceil(total / limit) };
 };
 
 module.exports = {
@@ -31,4 +58,7 @@ module.exports = {
   create,
   updateById,
   deleteById,
-};
+  findAll,
+<% if (hasSoftDelete) { %>  restoreById,
+  findDeleted,
+<% } %>};

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

@@ -21,6 +21,35 @@ const updateById = async (id, updateData) => {
 const deleteById = async (id) => {
   return await User.destroy({ where: { id } });
 };
+<% if (hasSoftDelete) { %>
+const restoreById = async (id) => {
+  return await User.restore({ where: { id } });
+};
+
+const findDeleted = async ({ page = 1, limit = 20 } = {}) => {
+  const offset = (page - 1) * limit;
+  const { rows: users, count: total } = await User.findAndCountAll({
+    where: { deletedAt: { [require('sequelize').Op.ne]: null } },
+    attributes: { exclude: ['password'] },
+    order: [['deletedAt', 'DESC']],
+    limit,
+    offset,
+    paranoid: false,
+  });
+  return { users, total, page, totalPages: Math.ceil(total / limit) };
+};
+<% } %>
+
+const findAll = async ({ page = 1, limit = 20 } = {}) => {
+  const offset = (page - 1) * limit;
+  const { rows: users, count: total } = await User.findAndCountAll({
+    attributes: { exclude: ['password'] },
+    order: [['createdAt', 'DESC']],
+    limit,
+    offset,
+  });
+  return { users, total, page, totalPages: Math.ceil(total / limit) };
+};
 
 module.exports = {
   findById,
@@ -28,4 +57,7 @@ module.exports = {
   create,
   updateById,
   deleteById,
-};
+  findAll,
+<% if (hasSoftDelete) { %>  restoreById,
+  findDeleted,
+<% } %>};

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

@@ -1,14 +1,14 @@
 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 },
+  return await prisma.user.findFirst({
+    where: { id<% if (hasSoftDelete) { %>, deletedAt: null<% } %> },
+    select: { id: true, username: true, email: true, role: true, createdAt: true, updatedAt: true },
   });
 };
 
 const findByEmail = async (email) => {
-  return await prisma.user.findUnique({ where: { email } });
+  return await prisma.user.findFirst({ where: { email<% if (hasSoftDelete) { %>, deletedAt: null<% } %> } });
 };
 
 const create = async (userData) => {
@@ -24,7 +24,48 @@ const updateById = async (id, updateData) => {
 };
 
 const deleteById = async (id) => {
-  return await prisma.user.delete({ where: { id } });
+<% if (hasSoftDelete) { %>  return await prisma.user.update({
+    where: { id },
+    data: { deletedAt: new Date() },
+  });
+<% } else { %>  return await prisma.user.delete({ where: { id } });
+<% } %>};
+<% if (hasSoftDelete) { %>
+const restoreById = async (id) => {
+  return await prisma.user.update({
+    where: { id },
+    data: { deletedAt: null },
+  });
+};
+
+const findDeleted = async ({ page = 1, limit = 20 } = {}) => {
+  const skip = (page - 1) * limit;
+  const [users, total] = await Promise.all([
+    prisma.user.findMany({
+      where: { deletedAt: { not: null } },
+      select: { id: true, username: true, email: true, role: true, deletedAt: true, createdAt: true },
+      orderBy: { deletedAt: 'desc' },
+      skip,
+      take: limit,
+    }),
+    prisma.user.count({ where: { deletedAt: { not: null } } }),
+  ]);
+  return { users, total, page, totalPages: Math.ceil(total / limit) };
+};
+<% } %>
+
+const findAll = async ({ page = 1, limit = 20 } = {}) => {
+  const skip = (page - 1) * limit;
+  const [users, total] = await Promise.all([
+    prisma.user.findMany({
+      select: { id: true, username: true, email: true, role: true, createdAt: true, updatedAt: true },
+      orderBy: { createdAt: 'desc' },
+      skip,
+      take: limit,
+    }),
+    prisma.user.count(),
+  ]);
+  return { users, total, page, totalPages: Math.ceil(total / limit) };
 };
 
 module.exports = {
@@ -33,4 +74,7 @@ module.exports = {
   create,
   updateById,
   deleteById,
-};
+  findAll,
+<% if (hasSoftDelete) { %>  restoreById,
+  findDeleted,
+<% } %>};