node --version
npm --version

# 安裝 Homebrew（如果尚未安裝）
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# 使用 Homebrew 安裝 Node.js
brew install node

# 使用 NodeSource 安裝腳本
curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
sudo apt-get install -y nodejs

# 拉取 MongoDB 鏡像
docker pull mongo:latest

# 運行 MongoDB 容器
docker run --name mongodb -d -p 27017:27017 -v ~/mongo/data:/data/db mongo:latest

# 帶認(rèn)證的啟動方式
docker run --name mongodb -d -p 27017:27017 -e MONGO_INITDB_ROOT_USERNAME=admin -e MONGO_INITDB_ROOT_PASSWORD=password -v ~/mongo/data:/data/db mongo:latest

# 創(chuàng)建項目目錄
mkdir blog-api
cd blog-api

# 初始化 npm 項目
npm init -y

# 創(chuàng)建項目目錄結(jié)構(gòu)
mkdir -p src/
mkdir -p src/controllers
mkdir -p src/models
mkdir -p src/routes
mkdir -p src/middleware
mkdir -p src/utils
mkdir -p src/config
mkdir -p tests
mkdir -p docs

# 創(chuàng)建基礎(chǔ)文件
touch src/app.js
touch src/server.js
touch .env
touch .gitignore
touch README.md

# 生產(chǎn)依賴
npm install express mongoose dotenv bcryptjs jsonwebtoken cors helmet morgan multer express-rate-limit express-validator

# 開發(fā)依賴
npm install --save-dev nodemon eslint prettier eslint-config-prettier eslint-plugin-prettier jest supertest mongodb-memory-server

{
  "scripts": {
    "start": "node src/server.js",
    "dev": "nodemon src/server.js",
    "test": "jest",
    "test:watch": "jest --watch",
    "lint": "eslint src/**/*.js",
    "lint:fix": "eslint src/**/*.js --fix",
    "format": "prettier --write src/**/*.js"
  }
}

# 依賴目錄
node_modules/

# 環(huán)境變量文件
.env
.env.local
.env.development.local
.env.test.local
.env.production.local

# 日志文件
logs/
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*

# 運行時數(shù)據(jù)
pids/
*.pid
*.seed
*.pid.lock

# 覆蓋率目錄
coverage/
.nyc_output

# 系統(tǒng)文件
.DS_Store
Thumbs.db

# IDE文件
.vscode/
.idea/
*.swp
*.swo

# 操作系統(tǒng)文件
*.DS_Store
Thumbs.db

const express = require('express');
const cors = require('cors');
const helmet = require('helmet');
const morgan = require('morgan');
const rateLimit = require('express-rate-limit');
require('dotenv').config();

// 導(dǎo)入路由
const postRoutes = require('./routes/posts');
const authRoutes = require('./routes/auth');
const userRoutes = require('./routes/users');

// 導(dǎo)入中間件
const errorHandler = require('./middleware/errorHandler');
const notFound = require('./middleware/notFound');

const app = express();

// 安全中間件
app.use(helmet());

// CORS 配置
app.use(cors({
  origin: process.env.NODE_ENV === 'production' 
    ? process.env.FRONTEND_URL 
    : 'http://localhost:3000',
  credentials: true
}));

// 速率限制
const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15分鐘
  max: 100, // 限制每個IP每15分鐘最多100個請求
  message: {
    error: '請求過于頻繁，請稍后再試。',
    status: 429
  }
});
app.use(limiter);

// 日志記錄
app.use(morgan(process.env.NODE_ENV === 'production' ? 'combined' : 'dev'));

// 解析請求體
app.use(express.json({ limit: '10mb' }));
app.use(express.urlencoded({ extended: true, limit: '10mb' }));

// 靜態(tài)文件服務(wù)
app.use('/uploads', express.static('uploads'));

// 路由配置
app.use('/api/posts', postRoutes);
app.use('/api/auth', authRoutes);
app.use('/api/users', userRoutes);

// 健康檢查端點
app.get('/api/health', (req, res) => {
  res.status(200).json({
    status: 'OK',
    timestamp: new Date().toISOString(),
    uptime: process.uptime(),
    environment: process.env.NODE_ENV || 'development'
  });
});

// 404處理
app.use(notFound);

// 錯誤處理
app.use(errorHandler);

module.exports = app;

const app = require('./app');
const connectDB = require('./config/database');

// 環(huán)境變量配置
const PORT = process.env.PORT || 5000;
const NODE_ENV = process.env.NODE_ENV || 'development';

// 優(yōu)雅關(guān)閉處理
const gracefulShutdown = (signal) => {
  console.log(`收到 ${signal}，開始優(yōu)雅關(guān)閉服務(wù)器...`);
  process.exit(0);
};

// 啟動服務(wù)器
const startServer = async () => {
  try {
    // 連接數(shù)據(jù)庫
    await connectDB();
    
    // 啟動Express服務(wù)器
    const server = app.listen(PORT, () => {
      console.log(`
?? 服務(wù)器已啟動！
?? 環(huán)境: ${NODE_ENV}
?? 端口: ${PORT}
?? 時間: ${new Date().toLocaleString()}
?? 健康檢查: http://localhost:${PORT}/api/health
      `);
    });

    // 優(yōu)雅關(guān)閉處理
    process.on('SIGINT', () => gracefulShutdown('SIGINT'));
    process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));

    // 處理未捕獲的異常
    process.on('uncaughtException', (error) => {
      console.error('未捕獲的異常:', error);
      gracefulShutdown('uncaughtException');
    });

    process.on('unhandledRejection', (reason, promise) => {
      console.error('未處理的Promise拒絕:', reason);
      gracefulShutdown('unhandledRejection');
    });

  } catch (error) {
    console.error('服務(wù)器啟動失敗:', error);
    process.exit(1);
  }
};

// 啟動應(yīng)用
startServer();

# 服務(wù)器配置
NODE_ENV=development
PORT=5000
FRONTEND_URL=http://localhost:3000

# 數(shù)據(jù)庫配置
MONGODB_URI=mongodb://localhost:27017/blog_api
MONGODB_URI_TEST=mongodb://localhost:27017/blog_api_test

# JWT配置
JWT_SECRET=your_super_secret_jwt_key_here_change_in_production
JWT_EXPIRE=7d
JWT_COOKIE_EXPIRE=7

# 文件上傳配置
MAX_FILE_UPLOAD=5
FILE_UPLOAD_PATH=./uploads

# 速率限制配置
RATE_LIMIT_WINDOW_MS=900000
RATE_LIMIT_MAX=100

# 郵件配置（可選）
SMTP_HOST=smtp.gmail.com
SMTP_PORT=587
SMTP_EMAIL=your_email@gmail.com
SMTP_PASSWORD=your_app_password
FROM_EMAIL=noreply@blogapi.com
FROM_NAME=Blog API

const Joi = require('joi');

// 環(huán)境變量驗證規(guī)則
const envVarsSchema = Joi.object({
  NODE_ENV: Joi.string()
    .valid('development', 'production', 'test')
    .default('development'),
  PORT: Joi.number().default(5000),
  MONGODB_URI: Joi.string().required().description('MongoDB連接字符串'),
  JWT_SECRET: Joi.string().required().description('JWT密鑰'),
  JWT_EXPIRE: Joi.string().default('7d').description('JWT過期時間'),
}).unknown().required();

// 驗證環(huán)境變量
const { value: envVars, error } = envVarsSchema.validate(process.env);
if (error) {
  throw new Error(`環(huán)境變量配置錯誤: ${error.message}`);
}

// 導(dǎo)出配置對象
module.exports = {
  env: envVars.NODE_ENV,
  port: envVars.PORT,
  mongoose: {
    url: envVars.MONGODB_URI + (envVars.NODE_ENV === 'test' ? '_test' : ''),
    options: {
      useNewUrlParser: true,
      useUnifiedTopology: true,
    },
  },
  jwt: {
    secret: envVars.JWT_SECRET,
    expire: envVars.JWT_EXPIRE,
  },
};

const mongoose = require('mongoose');
const config = require('./env');

const connectDB = async () => {
  try {
    const conn = await mongoose.connect(config.mongoose.url, config.mongoose.options);

    console.log(`
? MongoDB連接成功!
?? 主機: ${conn.connection.host}
?? 數(shù)據(jù)庫: ${conn.connection.name}
?? 狀態(tài): ${conn.connection.readyState === 1 ? '已連接' : '斷開'}
?? 時間: ${new Date().toLocaleString()}
    `);

    // 監(jiān)聽連接事件
    mongoose.connection.on('connected', () => {
      console.log('Mongoose已連接到數(shù)據(jù)庫');
    });

    mongoose.connection.on('error', (err) => {
      console.error('Mongoose連接錯誤:', err);
    });

    mongoose.connection.on('disconnected', () => {
      console.log('Mongoose已斷開數(shù)據(jù)庫連接');
    });

    // 進(jìn)程關(guān)閉時關(guān)閉數(shù)據(jù)庫連接
    process.on('SIGINT', async () => {
      await mongoose.connection.close();
      console.log('Mongoose連接已通過應(yīng)用終止關(guān)閉');
      process.exit(0);
    });

  } catch (error) {
    console.error('? MongoDB連接失敗:', error.message);
    process.exit(1);
  }
};

module.exports = connectDB;

const mongoose = require('mongoose');
const config = require('./env');

class DatabaseManager {
  constructor() {
    this.isConnected = false;
    this.connection = null;
    this.retryAttempts = 0;
    this.maxRetryAttempts = 5;
    this.retryDelay = 5000; // 5秒
  }

  async connect() {
    try {
      // 連接選項配置
      const options = {
        ...config.mongoose.options,
        poolSize: 10, // 連接池大小
        bufferMaxEntries: 0, // 禁用緩沖
        connectTimeoutMS: 10000, // 10秒連接超時
        socketTimeoutMS: 45000, // 45秒套接字超時
        family: 4, // 使用IPv4
        useCreateIndex: true,
        useFindAndModify: false
      };

      this.connection = await mongoose.connect(config.mongoose.url, options);
      this.isConnected = true;
      this.retryAttempts = 0;

      this.setupEventListeners();
      return this.connection;

    } catch (error) {
      console.error('數(shù)據(jù)庫連接失敗:', error.message);
      
      if (this.retryAttempts < this.maxRetryAttempts) {
        this.retryAttempts++;
        console.log(`嘗試重新連接 (${this.retryAttempts}/${this.maxRetryAttempts})...`);
        
        await new Promise(resolve => setTimeout(resolve, this.retryDelay));
        return this.connect();
      } else {
        throw new Error(`數(shù)據(jù)庫連接失敗，已達(dá)到最大重試次數(shù): ${this.maxRetryAttempts}`);
      }
    }
  }

  setupEventListeners() {
    mongoose.connection.on('connected', () => {
      console.log('Mongoose已連接到數(shù)據(jù)庫');
      this.isConnected = true;
    });

    mongoose.connection.on('error', (error) => {
      console.error('Mongoose連接錯誤:', error);
      this.isConnected = false;
    });

    mongoose.connection.on('disconnected', () => {
      console.log('Mongoose已斷開數(shù)據(jù)庫連接');
      this.isConnected = false;
    });

    mongoose.connection.on('reconnected', () => {
      console.log('Mongoose已重新連接到數(shù)據(jù)庫');
      this.isConnected = true;
    });
  }

  async disconnect() {
    if (this.isConnected) {
      await mongoose.disconnect();
      this.isConnected = false;
      console.log('Mongoose連接已關(guān)閉');
    }
  }

  getConnectionStatus() {
    return {
      isConnected: this.isConnected,
      readyState: mongoose.connection.readyState,
      host: mongoose.connection.host,
      name: mongoose.connection.name,
      retryAttempts: this.retryAttempts
    };
  }
}

// 創(chuàng)建單例實例
const databaseManager = new DatabaseManager();

module.exports = databaseManager;

const mongoose = require('mongoose');

const dbHealthCheck = async (req, res, next) => {
  try {
    const dbState = mongoose.connection.readyState;
    
    // readyState 值說明:
    // 0 = disconnected
    // 1 = connected
    // 2 = connecting
    // 3 = disconnecting
    
    if (dbState !== 1) {
      return res.status(503).json({
        success: false,
        error: '數(shù)據(jù)庫連接異常',
        details: {
          status: dbState,
          statusText: ['斷開連接', '已連接', '連接中', '斷開中'][dbState],
          timestamp: new Date().toISOString()
        }
      });
    }
    
    // 執(zhí)行簡單的查詢來驗證數(shù)據(jù)庫響應(yīng)
    await mongoose.connection.db.admin().ping();
    
    next();
  } catch (error) {
    res.status(503).json({
      success: false,
      error: '數(shù)據(jù)庫健康檢查失敗',
      details: {
        message: error.message,
        timestamp: new Date().toISOString()
      }
    });
  }
};

module.exports = dbHealthCheck;

const mongoose = require('mongoose');
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');
const config = require('../config/env');

const userSchema = new mongoose.Schema({
  username: {
    type: String,
    required: [true, '用戶名不能為空'],
    unique: true,
    trim: true,
    minlength: [3, '用戶名至少3個字符'],
    maxlength: [20, '用戶名不能超過20個字符'],
    match: [/^[a-zA-Z0-9_]+$/, '用戶名只能包含字母、數(shù)字和下劃線']
  },
  email: {
    type: String,
    required: [true, '郵箱不能為空'],
    unique: true,
    lowercase: true,
    trim: true,
    match: [/^\w+([.-]?\w+)*@\w+([.-]?\w+)*(\.\w{2,3})+$/, '請輸入有效的郵箱地址']
  },
  password: {
    type: String,
    required: [true, '密碼不能為空'],
    minlength: [6, '密碼至少6個字符'],
    select: false // 默認(rèn)不返回密碼字段
  },
  role: {
    type: String,
    enum: ['user', 'author', 'admin'],
    default: 'user'
  },
  avatar: {
    type: String,
    default: 'default-avatar.png'
  },
  bio: {
    type: String,
    maxlength: [500, '個人簡介不能超過500個字符'],
    default: ''
  },
  website: {
    type: String,
    match: [/https?:\/\/(www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_+.~#?&//=]*)/, '請輸入有效的網(wǎng)址']
  },
  isVerified: {
    type: Boolean,
    default: false
  },
  isActive: {
    type: Boolean,
    default: true
  },
  lastLogin: {
    type: Date,
    default: Date.now
  }
}, {
  timestamps: true,
  toJSON: { virtuals: true },
  toObject: { virtuals: true }
});

// 虛擬字段：用戶的文章
userSchema.virtual('posts', {
  ref: 'Post',
  localField: '_id',
  foreignField: 'author',
  justOne: false
});

// 索引優(yōu)化
userSchema.index({ email: 1 });
userSchema.index({ username: 1 });
userSchema.index({ createdAt: 1 });

// 密碼加密中間件
userSchema.pre('save', async function(next) {
  if (!this.isModified('password')) return next();
  
  try {
    const salt = await bcrypt.genSalt(12);
    this.password = await bcrypt.hash(this.password, salt);
    next();
  } catch (error) {
    next(error);
  }
});

// 比較密碼方法
userSchema.methods.comparePassword = async function(candidatePassword) {
  return await bcrypt.compare(candidatePassword, this.password);
};

// 生成JWT令牌方法
userSchema.methods.generateAuthToken = function() {
  return jwt.sign(
    { 
      userId: this._id,
      role: this.role 
    },
    config.jwt.secret,
    { 
      expiresIn: config.jwt.expire,
      issuer: 'blog-api',
      audience: 'blog-api-users'
    }
  );
};

// 獲取用戶基本信息（不包含敏感信息）
userSchema.methods.getPublicProfile = function() {
  const userObject = this.toObject();
  delete userObject.password;
  delete userObject.__v;
  return userObject;
};

// 靜態(tài)方法：通過郵箱查找用戶
userSchema.statics.findByEmail = function(email) {
  return this.findOne({ email: email.toLowerCase() });
};

// 靜態(tài)方法：通過用戶名查找用戶
userSchema.statics.findByUsername = function(username) {
  return this.findOne({ username: new RegExp('^' + username + '$', 'i') });
};

// 查詢中間件：自動過濾已刪除的用戶
userSchema.pre(/^find/, function(next) {
  this.find({ isActive: { $ne: false } });
  next();
});

module.exports = mongoose.model('User', userSchema);

const mongoose = require('mongoose');
const slugify = require('slugify');

const postSchema = new mongoose.Schema({
  title: {
    type: String,
    required: [true, '文章標(biāo)題不能為空'],
    trim: true,
    minlength: [5, '文章標(biāo)題至少5個字符'],
    maxlength: [200, '文章標(biāo)題不能超過200個字符']
  },
  slug: {
    type: String,
    unique: true,
    lowercase: true
  },
  content: {
    type: String,
    required: [true, '文章內(nèi)容不能為空'],
    minlength: [50, '文章內(nèi)容至少50個字符'],
    maxlength: [20000, '文章內(nèi)容不能超過20000個字符']
  },
  excerpt: {
    type: String,
    maxlength: [300, '文章摘要不能超過300個字符']
  },
  coverImage: {
    type: String,
    default: 'default-cover.jpg'
  },
  author: {
    type: mongoose.Schema.ObjectId,
    ref: 'User',
    required: true
  },
  tags: [{
    type: String,
    trim: true,
    lowercase: true
  }],
  category: {
    type: String,
    required: [true, '文章分類不能為空'],
    trim: true,
    enum: [
      'technology', 'programming', 'design', 'business', 
      'lifestyle', 'travel', 'food', 'health', 'education'
    ]
  },
  status: {
    type: String,
    enum: ['draft', 'published', 'archived'],
    default: 'draft'
  },
  isFeatured: {
    type: Boolean,
    default: false
  },
  viewCount: {
    type: Number,
    default: 0
  },
  likeCount: {
    type: Number,
    default: 0
  },
  commentCount: {
    type: Number,
    default: 0
  },
  readingTime: {
    type: Number, // 閱讀時間（分鐘）
    default: 0
  },
  meta: {
    title: String,
    description: String,
    keywords: [String]
  },
  publishedAt: Date
}, {
  timestamps: true,
  toJSON: { virtuals: true },
  toObject: { virtuals: true }
});

// 虛擬字段：評論
postSchema.virtual('comments', {
  ref: 'Comment',
  localField: '_id',
  foreignField: 'post',
  justOne: false
});

// 虛擬字段：點贊用戶
postSchema.virtual('likes', {
  ref: 'Like',
  localField: '_id',
  foreignField: 'post',
  justOne: false
});

// 索引優(yōu)化
postSchema.index({ title: 'text', content: 'text' });
postSchema.index({ author: 1, createdAt: -1 });
postSchema.index({ category: 1, status: 1 });
postSchema.index({ tags: 1 });
postSchema.index({ status: 1, publishedAt: -1 });
postSchema.index({ slug: 1 });

// 生成slug中間件
postSchema.pre('save', function(next) {
  if (this.isModified('title') && this.title) {
    this.slug = slugify(this.title, {
      lower: true,
      strict: true,
      remove: /[*+~.()'"!:@]/g
    });
  }
  next();
});

// 計算閱讀時間和摘要中間件
postSchema.pre('save', function(next) {
  if (this.isModified('content')) {
    // 計算閱讀時間（按每分鐘200字計算）
    const wordCount = this.content.trim().split(/\s+/).length;
    this.readingTime = Math.ceil(wordCount / 200);
    
    // 自動生成摘要
    if (!this.excerpt) {
      this.excerpt = this.content
        .replace(/[#*`~>]/g, '') // 移除Markdown標(biāo)記
        .substring(0, 200)
        .trim() + '...';
    }
  }
  next();
});

// 發(fā)布文章時設(shè)置發(fā)布時間
postSchema.pre('save', function(next) {
  if (this.isModified('status') && this.status === 'published' && !this.publishedAt) {
    this.publishedAt = new Date();
  }
  next();
});

// 靜態(tài)方法：獲取已發(fā)布文章
postSchema.statics.getPublishedPosts = function() {
  return this.find({ status: 'published' });
};

// 靜態(tài)方法：按分類獲取文章
postSchema.statics.getPostsByCategory = function(category) {
  return this.find({ 
    category: category.toLowerCase(), 
    status: 'published' 
  });
};

// 靜態(tài)方法：搜索文章
postSchema.statics.searchPosts = function(query) {
  return this.find({
    status: 'published',
    $text: { $search: query }
  }, { score: { $meta: 'textScore' } })
  .sort({ score: { $meta: 'textScore' } });
};

// 實例方法：增加瀏覽量
postSchema.methods.incrementViews = function() {
  this.viewCount += 1;
  return this.save();
};

// 查詢中間件：自動填充作者信息
postSchema.pre(/^find/, function(next) {
  this.populate({
    path: 'author',
    select: 'username avatar bio'
  });
  next();
});

module.exports = mongoose.model('Post', postSchema);

const mongoose = require('mongoose');

const commentSchema = new mongoose.Schema({
  content: {
    type: String,
    required: [true, '評論內(nèi)容不能為空'],
    trim: true,
    minlength: [1, '評論內(nèi)容至少1個字符'],
    maxlength: [1000, '評論內(nèi)容不能超過1000個字符']
  },
  author: {
    type: mongoose.Schema.ObjectId,
    ref: 'User',
    required: true
  },
  post: {
    type: mongoose.Schema.ObjectId,
    ref: 'Post',
    required: true
  },
  parentComment: {
    type: mongoose.Schema.ObjectId,
    ref: 'Comment',
    default: null
  },
  likes: {
    type: Number,
    default: 0
  },
  isEdited: {
    type: Boolean,
    default: false
  },
  isApproved: {
    type: Boolean,
    default: true
  }
}, {
  timestamps: true,
  toJSON: { virtuals: true },
  toObject: { virtuals: true }
});

// 虛擬字段：回復(fù)評論
commentSchema.virtual('replies', {
  ref: 'Comment',
  localField: '_id',
  foreignField: 'parentComment',
  justOne: false
});

// 索引優(yōu)化
commentSchema.index({ post: 1, createdAt: -1 });
commentSchema.index({ author: 1 });
commentSchema.index({ parentComment: 1 });

// 保存后更新文章的評論計數(shù)
commentSchema.post('save', async function() {
  const Post = mongoose.model('Post');
  await Post.findByIdAndUpdate(this.post, {
    $inc: { commentCount: 1 }
  });
});

// 刪除后更新文章的評論計數(shù)
commentSchema.post('findOneAndDelete', async function(doc) {
  if (doc) {
    const Post = mongoose.model('Post');
    await Post.findByIdAndUpdate(doc.post, {
      $inc: { commentCount: -1 }
    });
  }
});

// 查詢中間件：自動填充作者信息
commentSchema.pre(/^find/, function(next) {
  this.populate({
    path: 'author',
    select: 'username avatar'
  }).populate({
    path: 'replies',
    populate: {
      path: 'author',
      select: 'username avatar'
    }
  });
  next();
});

module.exports = mongoose.model('Comment', commentSchema);

const mongoose = require('mongoose');

const likeSchema = new mongoose.Schema({
  user: {
    type: mongoose.Schema.ObjectId,
    ref: 'User',
    required: true
  },
  post: {
    type: mongoose.Schema.ObjectId,
    ref: 'Post',
    required: true
  },
  type: {
    type: String,
    enum: ['like', 'love', 'laugh', 'wow', 'sad', 'angry'],
    default: 'like'
  }
}, {
  timestamps: true
});

// 復(fù)合唯一索引，確保一個用戶只能對一篇文章點一次贊
likeSchema.index({ user: 1, post: 1 }, { unique: true });

// 索引優(yōu)化
likeSchema.index({ post: 1 });
likeSchema.index({ user: 1 });

// 保存后更新文章的點贊計數(shù)
likeSchema.post('save', async function() {
  const Post = mongoose.model('Post');
  await Post.findByIdAndUpdate(this.post, {
    $inc: { likeCount: 1 }
  });
});

// 刪除后更新文章的點贊計數(shù)
likeSchema.post('findOneAndDelete', async function(doc) {
  if (doc) {
    const Post = mongoose.model('Post');
    await Post.findByIdAndUpdate(doc.post, {
      $inc: { likeCount: -1 }
    });
  }
});

module.exports = mongoose.model('Like', likeSchema);