express-genix 1.1.4 → 2.0.0

package/templates/migrations/create-users.js.ejs

@@ -0,0 +1,50 @@
+'use strict';
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable('users', {
+      id: {
+        type: Sequelize.UUID,
+        defaultValue: Sequelize.UUIDV4,
+        primaryKey: true,
+        allowNull: false,
+      },
+      username: {
+        type: Sequelize.STRING(50),
+        allowNull: false,
+        unique: true,
+      },
+      email: {
+        type: Sequelize.STRING(255),
+        allowNull: false,
+        unique: true,
+      },
+      password: {
+        type: Sequelize.STRING(255),
+        allowNull: false,
+      },
+      role: {
+        type: Sequelize.STRING(20),
+        allowNull: false,
+        defaultValue: 'user',
+      },
+      createdAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+        defaultValue: Sequelize.literal('NOW()'),
+      },
+      updatedAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+        defaultValue: Sequelize.literal('NOW()'),
+      },
+    });
+
+    await queryInterface.addIndex('users', ['email'], { unique: true });
+    await queryInterface.addIndex('users', ['username'], { unique: true });
+  },
+
+  async down(queryInterface) {
+    await queryInterface.dropTable('users');
+  },
+};

package/templates/migrations/seed-users.js.ejs

@@ -0,0 +1,34 @@
+'use strict';
+
+const bcrypt = require('bcryptjs');
+
+module.exports = {
+  async up(queryInterface) {
+    const hashedPassword = await bcrypt.hash('Password1', 12);
+
+    await queryInterface.bulkInsert('users', [
+      {
+        id: '00000000-0000-4000-a000-000000000001',
+        username: 'admin',
+        email: 'admin@example.com',
+        password: hashedPassword,
+        role: 'admin',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      },
+      {
+        id: '00000000-0000-4000-a000-000000000002',
+        username: 'testuser',
+        email: 'user@example.com',
+        password: hashedPassword,
+        role: 'user',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      },
+    ]);
+  },
+
+  async down(queryInterface) {
+    await queryInterface.bulkDelete('users', null, {});
+  },
+};

package/templates/migrations/sequelizerc.ejs

@@ -0,0 +1,8 @@
+const path = require('path');
+
+module.exports = {
+  config: path.resolve('src/config', 'database.js'),
+  'models-path': path.resolve('src/models'),
+  'migrations-path': path.resolve('migrations'),
+  'seeders-path': path.resolve('seeders'),
+};

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

@@ -1,30 +1,30 @@
-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,
-});
-
-
+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: [8, 'Password must be at least 8 characters long'],
+  },
+}, {
+  timestamps: true,
+});
+
+
 module.exports = mongoose.model('User', userSchema);

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

@@ -1,41 +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',
-});
-
+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: [8, 255],
+      notEmpty: true,
+    },
+  },
+}, {
+  timestamps: true,
+  tableName: 'users',
+});
+
 module.exports = User;

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

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

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

@@ -1,14 +1,223 @@
-// 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);
-
+const express = require('express');
+const authController = require('../controllers/authController');
+const { validateLogin, validateRegister, validate, forgotPasswordSchema, resetPasswordSchema } = require('../middleware/validation');
+const { authenticateToken } = require('../middleware/auth');
+
+const router = express.Router();
+
+/**
+ * @swagger
+ * /auth/register:
+ *   post:
+ *     summary: Register a new user
+ *     tags: [Authentication]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required: [username, email, password]
+ *             properties:
+ *               username:
+ *                 type: string
+ *                 minLength: 3
+ *                 maxLength: 50
+ *                 description: Display name (3-50 characters)
+ *                 example: johndoe
+ *               email:
+ *                 type: string
+ *                 format: email
+ *                 description: Valid email address
+ *                 example: john@example.com
+ *               password:
+ *                 type: string
+ *                 minLength: 8
+ *                 description: "Must contain at least one uppercase letter, one lowercase letter, and one number"
+ *                 example: Secret123
+ *           example:
+ *             username: johndoe
+ *             email: john@example.com
+ *             password: Secret123
+ *     responses:
+ *       201:
+ *         description: User registered successfully
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                   example: true
+ *                 data:
+ *                   type: object
+ *                   properties:
+ *                     message:
+ *                       type: string
+ *                     user:
+ *                       type: object
+ *                       properties:
+ *                         id:
+ *                           type: string
+ *                         username:
+ *                           type: string
+ *                         email:
+ *                           type: string
+ *                     accessToken:
+ *                       type: string
+ *                     refreshToken:
+ *                       type: string
+ *       400:
+ *         description: Validation error (weak password, invalid email, etc.)
+ *       409:
+ *         description: User already exists
+ */
+router.post('/register', validateRegister, authController.register);
+
+/**
+ * @swagger
+ * /auth/login:
+ *   post:
+ *     summary: Login user
+ *     tags: [Authentication]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required: [email, password]
+ *             properties:
+ *               email:
+ *                 type: string
+ *                 format: email
+ *                 example: john@example.com
+ *               password:
+ *                 type: string
+ *                 example: Secret123
+ *           example:
+ *             email: john@example.com
+ *             password: Secret123
+ *     responses:
+ *       200:
+ *         description: Login successful
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                   example: true
+ *                 data:
+ *                   type: object
+ *                   properties:
+ *                     message:
+ *                       type: string
+ *                     user:
+ *                       type: object
+ *                     accessToken:
+ *                       type: string
+ *                     refreshToken:
+ *                       type: string
+ *       401:
+ *         description: Invalid credentials
+ */
+router.post('/login', validateLogin, authController.login);
+
+/**
+ * @swagger
+ * /auth/refresh:
+ *   post:
+ *     summary: Refresh access token
+ *     tags: [Authentication]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required: [refreshToken]
+ *             properties:
+ *               refreshToken:
+ *                 type: string
+ *                 description: The refresh token received from login or register
+ *                 example: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
+ *     responses:
+ *       200:
+ *         description: Token refreshed
+ *       401:
+ *         description: Invalid refresh token
+ */
+router.post('/refresh', authController.refreshToken);
+
+/**
+ * @swagger
+ * /auth/logout:
+ *   post:
+ *     summary: Logout user
+ *     tags: [Authentication]
+ *     security:
+ *       - bearerAuth: []
+ *     responses:
+ *       200:
+ *         description: Logout successful
+ */
+router.post('/logout', authenticateToken, authController.logout);
+
+/**
+ * @swagger
+ * /auth/forgot-password:
+ *   post:
+ *     summary: Request password reset
+ *     tags: [Authentication]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required: [email]
+ *             properties:
+ *               email:
+ *                 type: string
+ *                 format: email
+ *                 example: john@example.com
+ *     responses:
+ *       200:
+ *         description: Reset link sent (if account exists)
+ */
+router.post('/forgot-password', validate({ body: forgotPasswordSchema }), authController.forgotPassword);
+
+/**
+ * @swagger
+ * /auth/reset-password:
+ *   post:
+ *     summary: Reset password with token
+ *     tags: [Authentication]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required: [token, password]
+ *             properties:
+ *               token:
+ *                 type: string
+ *                 description: The reset token from the password reset email
+ *               password:
+ *                 type: string
+ *                 minLength: 8
+ *                 description: "Must contain at least one uppercase letter, one lowercase letter, and one number"
+ *                 example: NewSecret123
+ *     responses:
+ *       200:
+ *         description: Password reset successful
+ *       400:
+ *         description: Invalid or expired reset token
+ */
+router.post('/reset-password', validate({ body: resetPasswordSchema }), authController.resetPassword);
+
 module.exports = router;

package/templates/routes/exampleRoutes.js.ejs

@@ -1,13 +1,101 @@
-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);
-
+const express = require('express');
+const exampleController = require('../controllers/exampleController');
+
+const router = express.Router();
+
+/**
+ * @swagger
+ * /examples:
+ *   get:
+ *     summary: Get all examples
+ *     tags: [Examples]
+ *     parameters:
+ *       - in: query
+ *         name: page
+ *         schema:
+ *           type: integer
+ *           default: 1
+ *         description: Page number
+ *       - in: query
+ *         name: limit
+ *         schema:
+ *           type: integer
+ *           default: 10
+ *         description: Items per page (max 100)
+ *     responses:
+ *       200:
+ *         description: Examples retrieved
+ *   post:
+ *     summary: Create new example
+ *     tags: [Examples]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required: [title, description]
+ *             properties:
+ *               title:
+ *                 type: string
+ *                 example: My First Example
+ *               description:
+ *                 type: string
+ *                 example: A description of the example item
+ *           example:
+ *             title: My First Example
+ *             description: A description of the example item
+ *     responses:
+ *       201:
+ *         description: Example created
+ */
+router.get('/', exampleController.getAllExamples);
+router.post('/', exampleController.createExample);
+
+/**
+ * @swagger
+ * /examples/{id}:
+ *   get:
+ *     summary: Get example by ID
+ *     tags: [Examples]
+ *     parameters:
+ *       - in: path
+ *         name: id
+ *         required: true
+ *         schema:
+ *           type: string
+ *     responses:
+ *       200:
+ *         description: Example retrieved
+ *       404:
+ *         description: Example not found
+ *   put:
+ *     summary: Update example
+ *     tags: [Examples]
+ *     parameters:
+ *       - in: path
+ *         name: id
+ *         required: true
+ *         schema:
+ *           type: string
+ *     responses:
+ *       200:
+ *         description: Example updated
+ *   delete:
+ *     summary: Delete example
+ *     tags: [Examples]
+ *     parameters:
+ *       - in: path
+ *         name: id
+ *         required: true
+ *         schema:
+ *           type: string
+ *     responses:
+ *       200:
+ *         description: Example deleted
+ */
+router.get('/:id', exampleController.getExampleById);
+router.put('/:id', exampleController.updateExample);
+router.delete('/:id', exampleController.deleteExample);
+
 module.exports = router;

package/templates/routes/index.js.ejs

@@ -1,24 +1,34 @@
-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;
+const express = require('express');
+<% if (hasAuth) { %>const authRoutes = require('./authRoutes');
+const userRoutes = require('./userRoutes');
+<% } else { %>const exampleRoutes = require('./exampleRoutes');
+<% } %>
+
+const router = express.Router();
+
+<% if (hasAuth) { %>router.use('/auth', authRoutes);
+router.use('/users', userRoutes);
+<% } else { %>router.use('/examples', exampleRoutes);
+<% } %>
+
+/**
+ * @swagger
+ * /api:
+ *   get:
+ *     summary: API root
+ *     responses:
+ *       200:
+ *         description: API information
+ */
+router.get('/', (req, res) => {
+  res.json({
+    success: true,
+    data: {
+      message: 'Welcome to the API',
+      version: '1.0.0',<% if (hasSwagger) { %>
+      documentation: '/api-docs',<% } %>
+    },
+  });
+});
+
+module.exports = router;