express-genix 1.1.0

package/templates/config/database.mongo.js.ejs

@@ -0,0 +1,36 @@
+const mongoose = require('mongoose');
+
+const mongoUri = process.env.MONGO_URI || 'mongodb://localhost:27017/<%= projectName %>';
+
+const connect = async () => {
+  try {
+    await mongoose.connect(mongoUri, {
+      useNewUrlParser: true,
+      useUnifiedTopology: true,
+    });
+    console.log('MongoDB connected successfully');
+  } catch (error) {
+    console.error('MongoDB connection error:', error);
+    process.exit(1);
+  }
+};
+
+const disconnect = async () => {
+  try {
+    await mongoose.disconnect();
+    console.log('MongoDB disconnected');
+  } catch (error) {
+    console.error('MongoDB disconnection error:', error);
+  }
+};
+
+// Handle connection events
+mongoose.connection.on('error', (error) => {
+  console.error('MongoDB connection error:', error);
+});
+
+mongoose.connection.on('disconnected', () => {
+  console.log('MongoDB disconnected');
+});
+
+module.exports = { connect, disconnect };

package/templates/config/database.postgres.js.ejs

@@ -0,0 +1,41 @@
+const { Sequelize } = require('sequelize');
+
+const databaseUrl = process.env.DATABASE_URL || 'postgresql://user:password@localhost:5432/<%= projectName %>';
+
+const sequelize = new Sequelize(databaseUrl, {
+  dialect: 'postgres',
+  logging: process.env.NODE_ENV === 'development' ? console.log : false,
+  pool: {
+    max: 5,
+    min: 0,
+    acquire: 30000,
+    idle: 10000,
+  },
+});
+
+const connect = async () => {
+  try {
+    await sequelize.authenticate();
+    console.log('PostgreSQL connected successfully');
+    
+    // Sync database in development
+    if (process.env.NODE_ENV === 'development') {
+      await sequelize.sync({ alter: true });
+      console.log('Database synced');
+    }
+  } catch (error) {
+    console.error('PostgreSQL connection error:', error);
+    process.exit(1);
+  }
+};
+
+const disconnect = async () => {
+  try {
+    await sequelize.close();
+    console.log('PostgreSQL disconnected');
+  } catch (error) {
+    console.error('PostgreSQL disconnection error:', error);
+  }
+};
+
+module.exports = { connect, disconnect, sequelize };

package/templates/config/swagger.json.ejs

@@ -0,0 +1,194 @@
+{
+    "openapi": "3.0.0",
+    "info": {
+      "title": "<%= projectName %> API",
+      "version": "1.0.0",
+      "description": "A production-grade Express boilerplate<% if (hasDatabase) { %> with JWT authentication<% } %>"
+    },
+    "servers": [
+      {
+        "url": "http://localhost:3000/api",
+        "description": "Development server"
+      }
+    ],<% if (hasDatabase) { %>
+    "components": {
+      "securitySchemes": {
+        "bearerAuth": {
+          "type": "http",
+          "scheme": "bearer",
+          "bearerFormat": "JWT"
+        }
+      }
+    },<% } %>
+    "paths": {<% if (hasDatabase) { %>
+      "/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" },
+                    "email": { "type": "string", "format": "email" },
+                    "password": { "type": "string", "minLength": 6 }
+                  }
+                }
+              }
+            }
+          },
+          "responses": {
+            "201": { "description": "User registered successfully" },
+            "409": { "description": "User already exists" }
+          }
+        }
+      },
+      "/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" },
+                    "password": { "type": "string" }
+                  }
+                }
+              }
+            }
+          },
+          "responses": {
+            "200": { "description": "Login successful" },
+            "401": { "description": "Invalid credentials" }
+          }
+        }
+      },
+      "/users/profile": {
+        "get": {
+          "summary": "Get user profile",
+          "tags": ["Users"],
+          "security": [{ "bearerAuth": [] }],
+          "responses": {
+            "200": { "description": "User profile retrieved" },
+            "401": { "description": "Unauthorized" }
+          }
+        }
+      }<% } else { %>
+      "/examples": {
+        "get": {
+          "summary": "Get all examples",
+          "tags": ["Examples"],
+          "parameters": [
+            {
+              "name": "page",
+              "in": "query",
+              "schema": { "type": "integer", "default": 1 }
+            },
+            {
+              "name": "limit",
+              "in": "query",
+              "schema": { "type": "integer", "default": 10 }
+            }
+          ],
+          "responses": {
+            "200": { "description": "Examples retrieved successfully" }
+          }
+        },
+        "post": {
+          "summary": "Create new example",
+          "tags": ["Examples"],
+          "requestBody": {
+            "required": true,
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "required": ["title", "description"],
+                  "properties": {
+                    "title": { "type": "string" },
+                    "description": { "type": "string" }
+                  }
+                }
+              }
+            }
+          },
+          "responses": {
+            "201": { "description": "Example created successfully" },
+            "400": { "description": "Invalid input" }
+          }
+        }
+      },
+      "/examples/{id}": {
+        "get": {
+          "summary": "Get example by ID",
+          "tags": ["Examples"],
+          "parameters": [
+            {
+              "name": "id",
+              "in": "path",
+              "required": true,
+              "schema": { "type": "string" }
+            }
+          ],
+          "responses": {
+            "200": { "description": "Example retrieved successfully" },
+            "404": { "description": "Example not found" }
+          }
+        },
+        "put": {
+          "summary": "Update example",
+          "tags": ["Examples"],
+          "parameters": [
+            {
+              "name": "id",
+              "in": "path",
+              "required": true,
+              "schema": { "type": "string" }
+            }
+          ],
+          "requestBody": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "title": { "type": "string" },
+                    "description": { "type": "string" }
+                  }
+                }
+              }
+            }
+          },
+          "responses": {
+            "200": { "description": "Example updated successfully" },
+            "404": { "description": "Example not found" }
+          }
+        },
+        "delete": {
+          "summary": "Delete example",
+          "tags": ["Examples"],
+          "parameters": [
+            {
+              "name": "id",
+              "in": "path",
+              "required": true,
+              "schema": { "type": "string" }
+            }
+          ],
+          "responses": {
+            "200": { "description": "Example deleted successfully" },
+            "404": { "description": "Example not found" }
+          }
+        }
+      }<% } %>
+    }
+  }

package/templates/controllers/authController.js.ejs

@@ -0,0 +1,129 @@
+const jwt = require('jsonwebtoken');
+const bcrypt = require('bcryptjs');
+const authService = require('../services/authService');
+const userService = require('../services/userService');
+const { AppError } = require('../utils/errors');
+
+const jwtSecret = process.env.JWT_SECRET || 'your-secret-key';
+const jwtRefreshSecret = process.env.JWT_REFRESH_SECRET || 'your-refresh-secret-key';
+
+const register = async (req, res, next) => {
+  try {
+    const { username, email, password } = req.body;
+    
+    // Check if user already exists
+    const existingUser = await userService.findByEmail(email);
+    if (existingUser) {
+      throw new AppError('User already exists with this email', 409);
+    }
+    
+    // Hash password
+    const hashedPassword = await bcrypt.hash(password, 12);
+    
+    // Create user
+    const user = await userService.create({
+      username,
+      email,
+      password: hashedPassword,
+    });
+    
+    // Generate tokens
+    const { accessToken, refreshToken } = authService.generateTokens(user);
+    
+    res.status(201).json({
+      message: 'User registered successfully',
+      user: { id: user.id, username: user.username, email: user.email },
+      accessToken,
+      refreshToken,
+    });
+  } catch (error) {
+    next(error);
+  }
+};
+
+const login = async (req, res, next) => {
+  try {
+    const { email, password } = req.body;
+    
+    // Find user
+    const user = await userService.findByEmail(email);
+    if (!user) {
+      throw new AppError('Invalid credentials', 401);
+    }
+    
+    // Check password
+    const isValidPassword = await bcrypt.compare(password, user.password);
+    if (!isValidPassword) {
+      throw new AppError('Invalid credentials', 401);
+    }
+    
+    // Generate tokens
+    const { accessToken, refreshToken } = authService.generateTokens(user);
+    
+    res.json({
+      message: 'Login successful',
+      user: { id: user.id, username: user.username, email: user.email },
+      accessToken,
+      refreshToken,
+    });
+  } catch (error) {
+    next(error);
+  }
+};
+
+const refreshToken = async (req, res, next) => {
+  try {
+    const { refreshToken } = req.body;
+    
+    if (!refreshToken) {
+      throw new AppError('Refresh token is required', 400);
+    }
+    
+    const decoded = jwt.verify(refreshToken, jwtRefreshSecret);
+    const user = await userService.findById(decoded.userId);
+    
+    if (!user) {
+      throw new AppError('Invalid refresh token', 401);
+    }
+    
+    const tokens = authService.generateTokens(user);
+    
+    res.json({
+      accessToken: tokens.accessToken,
+      refreshToken: tokens.refreshToken,
+    });
+  } catch (error) {
+    next(error);
+  }
+};
+
+const logout = (req, res) => {
+  // In a real app, you might want to blacklist the token
+  res.json({ message: 'Logout successful' });
+};
+
+const authenticateToken = (req, res, next) => {
+  const authHeader = req.headers['authorization'];
+  const token = authHeader && authHeader.split(' ')[1];
+  
+  if (!token) {
+    return res.status(401).json({ error: 'Access token is required' });
+  }
+  
+  jwt.verify(token, jwtSecret, (err, decoded) => {
+    if (err) {
+      return res.status(403).json({ error: 'Invalid or expired token' });
+    }
+    
+    req.user = decoded;
+    next();
+  });
+};
+
+module.exports = {
+  register,
+  login,
+  refreshToken,
+  logout,
+  authenticateToken,
+};

package/templates/controllers/exampleController.js.ejs

@@ -0,0 +1,152 @@
+const exampleService = require('../services/exampleService');
+const { AppError } = require('../utils/errors');
+const { createLogger } = require('../utils/logger');
+
+const logger = createLogger('ExampleController');
+
+/**
+ * Get all examples
+ */
+const getAllExamples = async (req, res, next) => {
+  try {
+    const { page = 1, limit = 10 } = req.query;
+    
+    logger.info('Fetching examples', { page, limit });
+    
+    const examples = await exampleService.getAllExamples(
+      parseInt(page),
+      parseInt(limit)
+    );
+    
+    res.json({
+      success: true,
+      data: examples,
+      pagination: {
+        page: parseInt(page),
+        limit: parseInt(limit),
+      },
+    });
+  } catch (error) {
+    logger.error('Error fetching examples', { error: error.message });
+    next(error);
+  }
+};
+
+/**
+ * Get example by ID
+ */
+const getExampleById = async (req, res, next) => {
+  try {
+    const { id } = req.params;
+    
+    logger.info('Fetching example by ID', { id });
+    
+    const example = await exampleService.getExampleById(id);
+    
+    if (!example) {
+      throw new AppError('Example not found', 404);
+    }
+    
+    res.json({
+      success: true,
+      data: example,
+    });
+  } catch (error) {
+    logger.error('Error fetching example', { id: req.params.id, error: error.message });
+    next(error);
+  }
+};
+
+/**
+ * Create new example
+ */
+const createExample = async (req, res, next) => {
+  try {
+    const { title, description } = req.body;
+    
+    if (!title || !description) {
+      throw new AppError('Title and description are required', 400);
+    }
+    
+    logger.info('Creating new example', { title });
+    
+    const example = await exampleService.createExample({
+      title,
+      description,
+      createdAt: new Date(),
+    });
+    
+    res.status(201).json({
+      success: true,
+      message: 'Example created successfully',
+      data: example,
+    });
+  } catch (error) {
+    logger.error('Error creating example', { error: error.message });
+    next(error);
+  }
+};
+
+/**
+ * Update example
+ */
+const updateExample = async (req, res, next) => {
+  try {
+    const { id } = req.params;
+    const { title, description } = req.body;
+    
+    logger.info('Updating example', { id });
+    
+    const example = await exampleService.updateExample(id, {
+      title,
+      description,
+      updatedAt: new Date(),
+    });
+    
+    if (!example) {
+      throw new AppError('Example not found', 404);
+    }
+    
+    res.json({
+      success: true,
+      message: 'Example updated successfully',
+      data: example,
+    });
+  } catch (error) {
+    logger.error('Error updating example', { id: req.params.id, error: error.message });
+    next(error);
+  }
+};
+
+/**
+ * Delete example
+ */
+const deleteExample = async (req, res, next) => {
+  try {
+    const { id } = req.params;
+    
+    logger.info('Deleting example', { id });
+    
+    const deleted = await exampleService.deleteExample(id);
+    
+    if (!deleted) {
+      throw new AppError('Example not found', 404);
+    }
+    
+    res.json({
+      success: true,
+      message: 'Example deleted successfully',
+    });
+  } catch (error) {
+    logger.error('Error deleting example', { id: req.params.id, error: error.message });
+    next(error);
+  }
+};
+
+module.exports = {
+  getAllExamples,
+  getExampleById,
+  createExample,
+  updateExample,
+  deleteExample,
+};

package/templates/controllers/userController.js.ejs

@@ -0,0 +1,60 @@
+const userService = require('../services/userService');
+const { AppError } = require('../utils/errors');
+
+const getProfile = async (req, res, next) => {
+  try {
+    const user = await userService.findById(req.user.userId);
+    if (!user) {
+      throw new AppError('User not found', 404);
+    }
+    
+    res.json({
+      user: {
+        id: user.id,
+        username: user.username,
+        email: user.email,
+        createdAt: user.createdAt,
+      },
+    });
+  } catch (error) {
+    next(error);
+  }
+};
+
+const updateProfile = async (req, res, next) => {
+  try {
+    const { username } = req.body;
+    const userId = req.user.userId;
+    
+    const updatedUser = await userService.updateById(userId, { username });
+    
+    res.json({
+      message: 'Profile updated successfully',
+      user: {
+        id: updatedUser.id,
+        username: updatedUser.username,
+        email: updatedUser.email,
+      },
+    });
+  } catch (error) {
+    next(error);
+  }
+};
+
+const deleteProfile = async (req, res, next) => {
+  try {
+    const userId = req.user.userId;
+    
+    await userService.deleteById(userId);
+    
+    res.json({ message: 'Profile deleted successfully' });
+  } catch (error) {
+    next(error);
+  }
+};
+
+module.exports = {
+  getProfile,
+  updateProfile,
+  deleteProfile,
+};

package/templates/core/Dockerfile.ejs

@@ -0,0 +1,32 @@
+# templates/core/Dockerfile.ejs
+FROM node:20-alpine
+
+# Set working directory
+WORKDIR /app
+
+# Copy package files
+COPY package*.json ./
+
+# Install dependencies
+RUN npm ci --only=production && npm cache clean --force
+
+# Copy application code
+COPY . .
+
+# Create non-root user
+RUN addgroup -g 1001 -S nodejs
+RUN adduser -S nodeuser -u 1001
+
+# Change ownership of app directory
+RUN chown -R nodeuser:nodejs /app
+USER nodeuser
+
+# Expose port
+EXPOSE 3000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+  CMD node healthcheck.js
+
+# Start application
+CMD ["npm", "start"]