## Project Overview This project is a Node.js backend application built using the Express framework. It includes essential modules such as routing, middleware, ORM for database interactions, authentication, and logging. The application is designed to be modular and easily extensible, following best practices for backend development. ## Project Directory Structure ``` my-express-app/ ├── src/ │ ├── config/ │ │ └── config.js │ ├── controllers/ │ │ └── userController.js │ ├── middleware/ │ │ └── authMiddleware.js │ ├── models/ │ │ └── userModel.js │ ├── routes/ │ │ └── userRoutes.js │ ├── services/ │ │ └── userService.js │ ├── utils/ │ │ └── logger.js │ └── app.js ├── .env ├── package.json └── README.md ``` ## Core Files Source Code ### 1. `src/app.js` ```javascript const express = require('express'); const mongoose = require('mongoose'); const userRoutes = require('./routes/userRoutes'); const { logger } = require('./utils/logger'); require('dotenv').config(); const app = express(); app.use(express.json()); app.use('/api/users', userRoutes); const PORT = process.env.PORT || 3000; mongoose.connect(process.env.DB_URI, { useNewUrlParser: true, useUnifiedTopology: true }) .then(() => { app.listen(PORT, () => { logger.info(`Server is running on port ${PORT}`); }); }) .catch(err => { logger.error('Database connection error:', err); }); ``` ### 2. `src/routes/userRoutes.js` ```javascript const express = require('express'); const { getUsers, createUser } = require('../controllers/userController'); const { authenticate } = require('../middleware/authMiddleware'); const router = express.Router(); router.get('/', authenticate, getUsers); router.post('/', createUser); module.exports = router; ``` ### 3. `src/controllers/userController.js` ```javascript const User = require('../models/userModel'); exports.getUsers = async (req, res) => { const users = await User.find(); res.json(users); }; exports.createUser = async (req, res) => { const user = new User(req.body); await user.save(); res.status(201).json(user); }; ``` ### 4. `src/models/userModel.js` ```javascript const mongoose = require('mongoose'); const userSchema = new mongoose.Schema({ username: { type: String, required: true }, password: { type: String, required: true }, }); module.exports = mongoose.model('User', userSchema); ``` ### 5. `src/middleware/authMiddleware.js` ```javascript exports.authenticate = (req, res, next) => { // Authentication logic here (e.g., JWT verification) next(); }; ``` ### 6. `src/utils/logger.js` ```javascript const winston = require('winston'); const logger = winston.createLogger({ level: 'info', format: winston.format.json(), transports: [ new winston.transports.Console(), ], }); module.exports = { logger }; ``` ## Dependencies List ```json { "dependencies": { "express": "^4.17.1", "mongoose": "^5.10.9", "dotenv": "^8.2.0", "winston": "^3.3.3" } } ``` ## Startup Instructions 1. Clone the repository: ```bash git clone <repository-url> cd my-express-app ``` 2. Install dependencies: ```bash npm install ``` 3. Create a `.env` file in the root directory and add the following: ``` DB_URI=mongodb://<username>:<password>@localhost:27017/mydatabase PORT=3000 ``` 4. Start the application: ```bash npm start ``` 5. Access the API at `http://localhost:3000/api/users`. This setup provides a solid foundation for building a scalable backend application using Node.js and Express with MySQL as the database.

# Express.js 項目腳手架 (MySQL + 認證系統) ## Project Overview 基于 Express.js 框架的標準后端項目骨架，包含路由模塊化、中間件系統、MySQL ORM 集成、JWT 認證和日志記錄功能。采用分層架構設計，遵循 RESTful 最佳實踐。 ## Project Directory Structure ``` express-mysql-starter/ ├── .env # 環境變量配置 ├── .gitignore ├── package.json # 項目配置與依賴 ├── README.md ├── app.js # 應用入口文件 ├── config/ # 配置目錄 │ ├── database.js # 數據庫配置 │ └── jwt.js # JWT 配置 ├── src/ │ ├── controllers/ # 控制器層 │ │ └── auth.controller.js │ ├── middlewares/ # 中間件 │ │ ├── auth.middleware.js │ │ └── logger.middleware.js │ ├── models/ # 數據模型 │ │ └── user.model.js │ ├── routes/ # 路由定義 │ │ ├── auth.routes.js │ │ └── index.routes.js │ ├── services/ # 業務邏輯 │ │ └── auth.service.js │ └── utils/ # 工具類 │ ├── logger.js │ └── apiError.js ├── logs/ # 日志目錄 └── db/ # 數據庫遷移腳本 ├── migrations/ └── seeders/ ``` ## Core Files Source Code ### 1. app.js (主入口) ```javascript require('dotenv').config(); const express = require('express'); const logger = require('./src/utils/logger'); const { sequelize } = require('./config/database'); const mainRouter = require('./src/routes/index.routes'); const app = express(); const PORT = process.env.PORT || 3000; // 中間件 app.use(express.json()); app.use(express.urlencoded({ extended: true })); app.use(require('./src/middlewares/logger.middleware')); // 路由 app.use('/api', mainRouter); // 數據庫連接測試 sequelize.authenticate() .then(() => logger.info('Database connected successfully')) .catch(err => logger.error('Database connection error:', err)); // 啟動服務器 app.listen(PORT, () => { logger.info(`Server running on port ${PORT}`); }); module.exports = app; ``` ### 2. MySQL 配置 (config/database.js) ```javascript const { Sequelize } = require('sequelize'); const logger = require('../src/utils/logger'); const sequelize = new Sequelize( process.env.DB_NAME, process.env.DB_USER, process.env.DB_PASSWORD, { host: process.env.DB_HOST, dialect: 'mysql', logging: msg => logger.debug(msg), pool: { max: 5, min: 0, acquire: 30000, idle: 10000 } } ); module.exports = { sequelize }; ``` ### 3. 用戶模型 (src/models/user.model.js) ```javascript const { DataTypes } = require('sequelize'); const { sequelize } = require('../../config/database'); const User = sequelize.define('User', { id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true }, username: { type: DataTypes.STRING, unique: true, allowNull: false }, email: { type: DataTypes.STRING, unique: true, allowNull: false, validate: { isEmail: true } }, password: { type: DataTypes.STRING, allowNull: false }, role: { type: DataTypes.ENUM('user', 'admin'), defaultValue: 'user' } }, { timestamps: true, paranoid: true }); module.exports = User; ``` ### 4. JWT 認證中間件 (src/middlewares/auth.middleware.js) ```javascript const jwt = require('jsonwebtoken'); const ApiError = require('../utils/apiError'); const logger = require('../utils/logger'); module.exports = { authenticate: (req, res, next) => { const token = req.header('Authorization')?.replace('Bearer ', ''); if (!token) { logger.warn('Authentication failed - No token provided'); return next(new ApiError(401, 'Access denied. No token provided.')); } try { const decoded = jwt.verify(token, process.env.JWT_SECRET); req.user = decoded; next(); } catch (ex) { logger.warn(`Authentication failed - Invalid token: ${ex.message}`); next(new ApiError(400, 'Invalid token.')); } }, authorize: (roles = []) => { if (typeof roles === 'string') roles = [roles]; return (req, res, next) => { if (!roles.includes(req.user.role)) { logger.warn(`Authorization failed for role ${req.user.role}`); return next(new ApiError(403, 'Access forbidden.')); } next(); }; } }; ``` ### 5. 日志工具 (src/utils/logger.js) ```javascript const winston = require('winston'); const { combine, timestamp, printf, colorize } = winston.format; const logFormat = printf(({ level, message, timestamp }) => { return `${timestamp} [${level}]: ${message}`; }); const logger = winston.createLogger({ level: process.env.LOG_LEVEL || 'info', format: combine( colorize(), timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), logFormat ), transports: [ new winston.transports.Console(), new winston.transports.File({ filename: 'logs/error.log', level: 'error' }), new winston.transports.File({ filename: 'logs/combined.log' }) ] }); module.exports = logger; ``` ## Dependencies List (package.json) ```json { "name": "express-mysql-starter", "version": "1.0.0", "description": "Express.js starter with MySQL and authentication", "main": "app.js", "scripts": { "start": "node app.js", "dev": "nodemon app.js", "test": "jest", "migrate": "sequelize-cli db:migrate", "seed": "sequelize-cli db:seed:all" }, "dependencies": { "bcryptjs": "^2.4.3", "dotenv": "^16.0.3", "express": "^4.18.2", "jsonwebtoken": "^9.0.0", "mysql2": "^3.2.0", "sequelize": "^6.30.0", "winston": "^3.9.0" }, "devDependencies": { "nodemon": "^2.0.22", "sequelize-cli": "^6.6.0", "jest": "^29.5.0", "supertest": "^6.3.3" } } ``` ## Startup Instructions 1. **環境準備**: ```bash # 安裝 Node.js (v16+) 和 MySQL (v8+) # 克隆項目 git clone <repository-url> cd express-mysql-starter ``` 2. **安裝依賴**: ```bash npm install ``` 3. **配置環境變量**: 創建 `.env` 文件并配置: ```env PORT=3000 DB_HOST=localhost DB_PORT=3306 DB_NAME=your_database DB_USER=your_username DB_PASSWORD=your_password JWT_SECRET=your_jwt_secret_key LOG_LEVEL=debug ``` 4. **數據庫設置**: ```bash # 運行遷移 npx sequelize-cli db:migrate # 可選: 運行種子數據 npx sequelize-cli db:seed:all ``` 5. **啟動項目**: ```bash # 開發模式 (帶熱重載) npm run dev # 生產模式 npm start ``` 6. **測試 API**: - 訪問 `http://localhost:3000/api/health` 檢查服務狀態 - 使用 Postman 測試認證端點 (`/api/auth/register`, `/api/auth/login`) 7. **查看日志**: - 控制臺實時輸出 - 日志文件保存在 `logs/` 目錄下 項目默認包含以下 API 端點: - `POST /api/auth/register` - 用戶注冊 - `POST /api/auth/login` - 用戶登錄 - `GET /api/auth/me` - 獲取當前用戶信息 (需要認證)

```markdown # Project Overview 本項目是一個使用 Node.js 和 Express 構建的后端應用程序模板，集成了常用的模塊以支持快速開發。這些模塊包括路由、ORM、認證、日志功能等，并且配置了 MySQL 數據庫。此項目遵循最佳開發實踐，具有良好的可擴展性。 # Project Directory Structure ``` my-express-app/ ├── src/ │ ├── config/ │ │ ├── database.js │ │ ├── logger.js │ │ └── dotenv.js │ ├── controllers/ │ │ └── authController.js │ ├── middlewares/ │ │ ├── authMiddleware.js │ │ └── loggerMiddleware.js │ ├── models/ │ │ └── user.js │ ├── routes/ │ │ └── index.js │ ├── utils/ │ │ └── errorHandler.js │ └── app.js ├── .env.example ├── package.json └── README.md ``` # Core Files Source Code ### `src/config/database.js` ```javascript const { Sequelize } = require('sequelize'); const sequelize = new Sequelize(process.env.DB_NAME, process.env.DB_USER, process.env.DB_PASSWORD, { host: process.env.DB_HOST, dialect: 'mysql', }); module.exports = sequelize; ``` ### `src/config/logger.js` ```javascript const winston = require('winston'); const logger = winston.createLogger({ level: 'info', format: winston.format.json(), transports: [ new winston.transports.Console(), ], }); module.exports = logger; ``` ### `src/config/dotenv.js` ```javascript require('dotenv').config(); ``` ### `src/controllers/authController.js` ```javascript const jwt = require('jsonwebtoken'); const User = require('../models/user'); const bcrypt = require('bcryptjs'); exports.login = async (req, res) => { // Authentication logic here }; exports.register = async (req, res) => { // User registration logic here }; ``` ### `src/middlewares/authMiddleware.js` ```javascript const jwt = require('jsonwebtoken'); module.exports = (req, res, next) => { // JWT authentication middleware logic }; ``` ### `src/middlewares/loggerMiddleware.js` ```javascript const logger = require('../config/logger'); module.exports = (req, res, next) => { logger.info(`${req.method} ${req.url}`); next(); }; ``` ### `src/models/user.js` ```javascript const { DataTypes } = require('sequelize'); const sequelize = require('../config/database'); const User = sequelize.define('User', { username: { type: DataTypes.STRING, allowNull: false, unique: true }, password: { type: DataTypes.STRING, allowNull: false } }); module.exports = User; ``` ### `src/routes/index.js` ```javascript const express = require('express'); const authController = require('../controllers/authController'); const authMiddleware = require('../middlewares/authMiddleware'); const router = express.Router(); router.post('/login', authController.login); router.post('/register', authController.register); module.exports = router; ``` ### `src/utils/errorHandler.js` ```javascript module.exports = (err, req, res, next) => { res.status(500).json({ error: err.message }); }; ``` ### `src/app.js` ```javascript const express = require('express'); const dotenv = require('./config/dotenv'); const loggerMiddleware = require('./middlewares/loggerMiddleware'); const routes = require('./routes/index'); const errorHandler = require('./utils/errorHandler'); const sequelize = require('./config/database'); const app = express(); app.use(express.json()); app.use(loggerMiddleware); app.use('/api', routes); app.use(errorHandler); const PORT = process.env.PORT || 3000; sequelize.authenticate().then(() => { console.log('Database connected.'); app.listen(PORT, () => { console.log(`Server running on port ${PORT}`); }); }).catch(err => { console.error('Unable to connect to the database:', err); }); ``` ### `.env.example` ```plaintext PORT=3000 DB_NAME=your_database_name DB_USER=your_username DB_PASSWORD=your_password DB_HOST=localhost JWT_SECRET=your_jwt_secret ``` # Dependencies List - express - sequelize - mysql2 - dotenv - winston - jsonwebtoken - bcryptjs # Startup Instructions 1. **Clone the repository**: ```bash git clone <repository-url> ``` 2. **Navigate into the project directory**: ```bash cd my-express-app ``` 3. **Install dependencies**: ```bash npm install ``` 4. **Copy the `.env.example` to `.env` and fill in your credentials**. 5. **Run the application**: ```bash npm start ``` 6. **Access the server** at `http://localhost:3000`. ```

# Project Overview This project is a Node.js application using the Express framework. It includes essential modules such as routing, middleware, ORM (using Sequelize for MySQL), authentication (using JWT), and logging. The project structure is designed to be modular and scalable, adhering to best practices in backend development. # Project Directory Structure ``` /project-name │ ├── /config │ └── db.config.js │ ├── /controllers │ └── auth.controller.js │ ├── /middlewares │ ├── auth.middleware.js │ └── logger.middleware.js │ ├── /models │ └── user.model.js │ ├── /routes │ └── auth.routes.js │ ├── /utils │ └── jwt.utils.js │ ├── .env ├── app.js ├── package.json └── server.js ``` # Core Files Source Code ## `/config/db.config.js` ```javascript const { Sequelize } = require('sequelize'); const sequelize = new Sequelize(process.env.DB_NAME, process.env.DB_USER, process.env.DB_PASSWORD, { host: process.env.DB_HOST, dialect: 'mysql', }); module.exports = sequelize; ``` ## `/controllers/auth.controller.js` ```javascript const jwt = require('jsonwebtoken'); const bcrypt = require('bcryptjs'); const User = require('../models/user.model'); exports.register = async (req, res) => { try { const hashedPassword = await bcrypt.hash(req.body.password, 8); const user = await User.create({ username: req.body.username, password: hashedPassword }); res.status(201).send(user); } catch (error) { res.status(500).send(error); } }; exports.login = async (req, res) => { try { const user = await User.findOne({ where: { username: req.body.username } }); if (!user || !(await bcrypt.compare(req.body.password, user.password))) { return res.status(401).send({ message: 'Invalid Credentials' }); } const token = jwt.sign({ id: user.id }, process.env.JWT_SECRET, { expiresIn: 86400 }); // 24 hours res.status(200).send({ auth: true, token }); } catch (error) { res.status(500).send(error); } }; ``` ## `/middlewares/auth.middleware.js` ```javascript const jwt = require('jsonwebtoken'); const verifyToken = (req, res, next) => { const token = req.headers['x-access-token']; if (!token) { return res.status(403).send({ message: 'No token provided!' }); } jwt.verify(token, process.env.JWT_SECRET, (err, decoded) => { if (err) { return res.status(401).send({ message: 'Unauthorized!' }); } req.userId = decoded.id; next(); }); }; module.exports = verifyToken; ``` ## `/middlewares/logger.middleware.js` ```javascript const logger = (req, res, next) => { console.log(`${new Date().toISOString()} - ${req.method} ${req.url}`); next(); }; module.exports = logger; ``` ## `/models/user.model.js` ```javascript const { DataTypes } = require('sequelize'); const sequelize = require('../config/db.config'); const User = sequelize.define('User', { username: { type: DataTypes.STRING, allowNull: false, unique: true, }, password: { type: DataTypes.STRING, allowNull: false, }, }); module.exports = User; ``` ## `/routes/auth.routes.js` ```javascript const express = require('express'); const router = express.Router(); const authController = require('../controllers/auth.controller'); const authMiddleware = require('../middlewares/auth.middleware'); router.post('/register', authController.register); router.post('/login', authController.login); module.exports = router; ``` ## `/utils/jwt.utils.js` ```javascript const jwt = require('jsonwebtoken'); const generateToken = (userId) => { return jwt.sign({ id: userId }, process.env.JWT_SECRET, { expiresIn: 86400 }); // 24 hours }; module.exports = generateToken; ``` ## `.env` ``` DB_NAME=your_db_name DB_USER=your_db_user DB_PASSWORD=your_db_password DB_HOST=localhost JWT_SECRET=your_jwt_secret ``` ## `app.js` ```javascript const express = require('express'); const bodyParser = require('body-parser'); const loggerMiddleware = require('./middlewares/logger.middleware'); const authRoutes = require('./routes/auth.routes'); const app = express(); app.use(bodyParser.json()); app.use(loggerMiddleware); app.use('/api/auth', authRoutes); module.exports = app; ``` ## `server.js` ```javascript const app = require('./app'); const sequelize = require('./config/db.config'); const PORT = process.env.PORT || 3000; sequelize.sync() .then(() => { app.listen(PORT, () => { console.log(`Server is running on port ${PORT}.`); }); }) .catch((err) => { console.error('Unable to connect to the database:', err); }); ``` # Dependencies List ```json { "dependencies": { "bcryptjs": "^2.4.3", "dotenv": "^16.0.3", "express": "^4.18.2", "jsonwebtoken": "^9.0.0", "mysql2": "^3.1.0", "sequelize": "^6.28.0" } } ``` # Startup Instructions 1. Clone the repository. 2. Install dependencies: ```bash npm install ``` 3. Set up your environment variables in the `.env` file. 4. Start the server: ```bash node server.js ``` 5. The server will start on `http://localhost:3000`. You can test the API endpoints using tools like Postman or curl.