collabdocchat 1.2.13 → 2.0.1

package/server/utils/backup.js

@@ -0,0 +1,439 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import archiver from 'archiver';
+import mongoose from 'mongoose';
+import cron from 'node-cron';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+class BackupService {
+  constructor() {
+    this.backupDir = path.join(__dirname, '../../backups');
+    this.maxBackups = 30; // 保留最近30个备份
+    this.isBackingUp = false;
+    
+    // 确保备份目录存在
+    if (!fs.existsSync(this.backupDir)) {
+      fs.mkdirSync(this.backupDir, { recursive: true });
+    }
+  }
+
+  // 初始化自动备份任务
+  initAutoBackup() {
+    // 每天凌晨2点执行备份
+    cron.schedule('0 2 * * *', async () => {
+      console.log('开始执行自动备份...');
+      try {
+        await this.createBackup('auto');
+        console.log('自动备份完成');
+      } catch (error) {
+        console.error('自动备份失败:', error);
+      }
+    });
+
+    console.log('✅ 自动备份任务已启动（每天凌晨2点执行）');
+  }
+
+  // 创建备份
+  async createBackup(type = 'manual', description = '') {
+    if (this.isBackingUp) {
+      throw new Error('备份正在进行中，请稍后再试');
+    }
+
+    this.isBackingUp = true;
+
+    try {
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const backupName = `backup_${type}_${timestamp}`;
+      const backupPath = path.join(this.backupDir, backupName);
+
+      // 创建备份目录
+      if (!fs.existsSync(backupPath)) {
+        fs.mkdirSync(backupPath, { recursive: true });
+      }
+
+      console.log(`创建备份: ${backupName}`);
+
+      // 1. 导出数据库
+      await this.exportDatabase(backupPath);
+
+      // 2. 备份上传文件
+      await this.backupUploads(backupPath);
+
+      // 3. 创建备份元数据
+      const metadata = {
+        name: backupName,
+        type,
+        description,
+        createdAt: new Date().toISOString(),
+        size: this.getDirectorySize(backupPath),
+        collections: await this.getCollectionStats()
+      };
+
+      fs.writeFileSync(
+        path.join(backupPath, 'metadata.json'),
+        JSON.stringify(metadata, null, 2)
+      );
+
+      // 4. 压缩备份
+      const zipPath = await this.compressBackup(backupPath, backupName);
+
+      // 5. 删除未压缩的备份目录
+      this.removeDirectory(backupPath);
+
+      // 6. 清理旧备份
+      await this.cleanOldBackups();
+
+      console.log(`备份完成: ${zipPath}`);
+
+      return {
+        success: true,
+        backupName,
+        zipPath,
+        metadata
+      };
+    } catch (error) {
+      console.error('备份失败:', error);
+      throw error;
+    } finally {
+      this.isBackingUp = false;
+    }
+  }
+
+  // 导出数据库
+  async exportDatabase(backupPath) {
+    const dbPath = path.join(backupPath, 'database');
+    if (!fs.existsSync(dbPath)) {
+      fs.mkdirSync(dbPath, { recursive: true });
+    }
+
+    // 获取所有集合
+    const collections = await mongoose.connection.db.listCollections().toArray();
+
+    for (const collection of collections) {
+      const collectionName = collection.name;
+      console.log(`导出集合: ${collectionName}`);
+
+      const data = await mongoose.connection.db
+        .collection(collectionName)
+        .find({})
+        .toArray();
+
+      fs.writeFileSync(
+        path.join(dbPath, `${collectionName}.json`),
+        JSON.stringify(data, null, 2)
+      );
+    }
+  }
+
+  // 备份上传文件
+  async backupUploads(backupPath) {
+    const uploadsDir = path.join(__dirname, '../../uploads');
+    const backupUploadsDir = path.join(backupPath, 'uploads');
+
+    if (!fs.existsSync(uploadsDir)) {
+      console.log('上传目录不存在，跳过文件备份');
+      return;
+    }
+
+    console.log('备份上传文件...');
+    this.copyDirectory(uploadsDir, backupUploadsDir);
+  }
+
+  // 压缩备份
+  async compressBackup(backupPath, backupName) {
+    return new Promise((resolve, reject) => {
+      const zipPath = `${backupPath}.zip`;
+      const output = fs.createWriteStream(zipPath);
+      const archive = archiver('zip', {
+        zlib: { level: 9 }
+      });
+
+      output.on('close', () => {
+        console.log(`备份已压缩: ${archive.pointer()} bytes`);
+        resolve(zipPath);
+      });
+
+      archive.on('error', (err) => {
+        reject(err);
+      });
+
+      archive.pipe(output);
+      archive.directory(backupPath, false);
+      archive.finalize();
+    });
+  }
+
+  // 恢复备份
+  async restoreBackup(backupName) {
+    const backupZipPath = path.join(this.backupDir, `${backupName}.zip`);
+
+    if (!fs.existsSync(backupZipPath)) {
+      throw new Error('备份文件不存在');
+    }
+
+    console.log(`开始恢复备份: ${backupName}`);
+
+    // 1. 解压备份
+    const extractPath = path.join(this.backupDir, 'temp_restore');
+    if (fs.existsSync(extractPath)) {
+      this.removeDirectory(extractPath);
+    }
+    fs.mkdirSync(extractPath, { recursive: true });
+
+    await this.extractZip(backupZipPath, extractPath);
+
+    // 2. 读取元数据
+    const metadata = JSON.parse(
+      fs.readFileSync(path.join(extractPath, 'metadata.json'), 'utf8')
+    );
+
+    console.log('备份元数据:', metadata);
+
+    // 3. 恢复数据库
+    await this.restoreDatabase(path.join(extractPath, 'database'));
+
+    // 4. 恢复上传文件
+    await this.restoreUploads(path.join(extractPath, 'uploads'));
+
+    // 5. 清理临时文件
+    this.removeDirectory(extractPath);
+
+    console.log('备份恢复完成');
+
+    return {
+      success: true,
+      metadata
+    };
+  }
+
+  // 恢复数据库
+  async restoreDatabase(dbPath) {
+    if (!fs.existsSync(dbPath)) {
+      console.log('数据库备份不存在，跳过恢复');
+      return;
+    }
+
+    const files = fs.readdirSync(dbPath);
+
+    for (const file of files) {
+      if (!file.endsWith('.json')) continue;
+
+      const collectionName = file.replace('.json', '');
+      console.log(`恢复集合: ${collectionName}`);
+
+      const data = JSON.parse(
+        fs.readFileSync(path.join(dbPath, file), 'utf8')
+      );
+
+      // 清空现有数据
+      await mongoose.connection.db.collection(collectionName).deleteMany({});
+
+      // 插入备份数据
+      if (data.length > 0) {
+        await mongoose.connection.db.collection(collectionName).insertMany(data);
+      }
+    }
+  }
+
+  // 恢复上传文件
+  async restoreUploads(backupUploadsDir) {
+    if (!fs.existsSync(backupUploadsDir)) {
+      console.log('上传文件备份不存在，跳过恢复');
+      return;
+    }
+
+    const uploadsDir = path.join(__dirname, '../../uploads');
+
+    console.log('恢复上传文件...');
+
+    // 备份当前上传文件
+    if (fs.existsSync(uploadsDir)) {
+      const backupCurrentUploads = path.join(
+        this.backupDir,
+        `uploads_before_restore_${Date.now()}`
+      );
+      this.copyDirectory(uploadsDir, backupCurrentUploads);
+      console.log(`当前上传文件已备份到: ${backupCurrentUploads}`);
+    }
+
+    // 恢复上传文件
+    this.copyDirectory(backupUploadsDir, uploadsDir);
+  }
+
+  // 获取备份列表
+  getBackupList() {
+    const files = fs.readdirSync(this.backupDir);
+    const backups = [];
+
+    for (const file of files) {
+      if (!file.endsWith('.zip')) continue;
+
+      const filePath = path.join(this.backupDir, file);
+      const stats = fs.statSync(filePath);
+
+      backups.push({
+        name: file.replace('.zip', ''),
+        filename: file,
+        size: stats.size,
+        createdAt: stats.birthtime,
+        path: filePath
+      });
+    }
+
+    // 按创建时间倒序排列
+    backups.sort((a, b) => b.createdAt - a.createdAt);
+
+    return backups;
+  }
+
+  // 删除备份
+  deleteBackup(backupName) {
+    const backupPath = path.join(this.backupDir, `${backupName}.zip`);
+
+    if (!fs.existsSync(backupPath)) {
+      throw new Error('备份文件不存在');
+    }
+
+    fs.unlinkSync(backupPath);
+    console.log(`备份已删除: ${backupName}`);
+
+    return { success: true };
+  }
+
+  // 清理旧备份
+  async cleanOldBackups() {
+    const backups = this.getBackupList();
+
+    if (backups.length <= this.maxBackups) {
+      return;
+    }
+
+    console.log(`清理旧备份，保留最近 ${this.maxBackups} 个`);
+
+    const backupsToDelete = backups.slice(this.maxBackups);
+
+    for (const backup of backupsToDelete) {
+      try {
+        fs.unlinkSync(backup.path);
+        console.log(`已删除旧备份: ${backup.name}`);
+      } catch (error) {
+        console.error(`删除备份失败: ${backup.name}`, error);
+      }
+    }
+  }
+
+  // 获取集合统计信息
+  async getCollectionStats() {
+    const collections = await mongoose.connection.db.listCollections().toArray();
+    const stats = {};
+
+    for (const collection of collections) {
+      const count = await mongoose.connection.db
+        .collection(collection.name)
+        .countDocuments();
+      stats[collection.name] = count;
+    }
+
+    return stats;
+  }
+
+  // 获取目录大小
+  getDirectorySize(dirPath) {
+    let size = 0;
+
+    if (!fs.existsSync(dirPath)) {
+      return size;
+    }
+
+    const files = fs.readdirSync(dirPath);
+
+    for (const file of files) {
+      const filePath = path.join(dirPath, file);
+      const stats = fs.statSync(filePath);
+
+      if (stats.isDirectory()) {
+        size += this.getDirectorySize(filePath);
+      } else {
+        size += stats.size;
+      }
+    }
+
+    return size;
+  }
+
+  // 复制目录
+  copyDirectory(src, dest) {
+    if (!fs.existsSync(dest)) {
+      fs.mkdirSync(dest, { recursive: true });
+    }
+
+    const files = fs.readdirSync(src);
+
+    for (const file of files) {
+      const srcPath = path.join(src, file);
+      const destPath = path.join(dest, file);
+      const stats = fs.statSync(srcPath);
+
+      if (stats.isDirectory()) {
+        this.copyDirectory(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+
+  // 删除目录
+  removeDirectory(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+      return;
+    }
+
+    const files = fs.readdirSync(dirPath);
+
+    for (const file of files) {
+      const filePath = path.join(dirPath, file);
+      const stats = fs.statSync(filePath);
+
+      if (stats.isDirectory()) {
+        this.removeDirectory(filePath);
+      } else {
+        fs.unlinkSync(filePath);
+      }
+    }
+
+    fs.rmdirSync(dirPath);
+  }
+
+  // 解压ZIP文件
+  async extractZip(zipPath, extractPath) {
+    // 注意：这里需要使用 unzipper 或 extract-zip 库
+    // 为了简化，这里使用命令行工具
+    const { exec } = await import('child_process');
+    const { promisify } = await import('util');
+    const execAsync = promisify(exec);
+
+    try {
+      // Windows
+      await execAsync(`powershell Expand-Archive -Path "${zipPath}" -DestinationPath "${extractPath}" -Force`);
+    } catch (error) {
+      // Linux/Mac
+      await execAsync(`unzip -o "${zipPath}" -d "${extractPath}"`);
+    }
+  }
+
+  // 格式化文件大小
+  formatSize(bytes) {
+    if (bytes === 0) return '0 Bytes';
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return Math.round(bytes / Math.pow(k, i) * 100) / 100 + ' ' + sizes[i];
+  }
+}
+
+export default new BackupService();
+

package/server/utils/cache.js

@@ -0,0 +1,223 @@
+import { createClient } from 'redis';
+
+class CacheService {
+  constructor() {
+    this.client = null;
+    this.isConnected = false;
+  }
+
+  async connect() {
+    try {
+      this.client = createClient({
+        url: process.env.REDIS_URL || 'redis://localhost:6379',
+        socket: {
+          reconnectStrategy: (retries) => {
+            if (retries > 10) {
+              console.log('❌ Redis 重连次数过多，停止重连');
+              return new Error('Redis 连接失败');
+            }
+            return retries * 100;
+          }
+        }
+      });
+
+      this.client.on('error', (err) => {
+        console.error('❌ Redis 错误:', err);
+        this.isConnected = false;
+      });
+
+      this.client.on('connect', () => {
+        console.log('🔌 Redis 正在连接...');
+      });
+
+      this.client.on('ready', () => {
+        console.log('✅ Redis 连接成功');
+        this.isConnected = true;
+      });
+
+      this.client.on('reconnecting', () => {
+        console.log('🔄 Redis 正在重连...');
+      });
+
+      await this.client.connect();
+    } catch (error) {
+      console.error('❌ Redis 连接失败:', error.message);
+      console.log('⚠️  应用将在没有缓存的情况下运行');
+      this.isConnected = false;
+    }
+  }
+
+  async get(key) {
+    if (!this.isConnected) return null;
+    
+    try {
+      const data = await this.client.get(key);
+      return data ? JSON.parse(data) : null;
+    } catch (error) {
+      console.error('Redis GET 错误:', error);
+      return null;
+    }
+  }
+
+  async set(key, value, ttl = 300) {
+    if (!this.isConnected) return false;
+    
+    try {
+      await this.client.setEx(key, ttl, JSON.stringify(value));
+      return true;
+    } catch (error) {
+      console.error('Redis SET 错误:', error);
+      return false;
+    }
+  }
+
+  async del(key) {
+    if (!this.isConnected) return false;
+    
+    try {
+      await this.client.del(key);
+      return true;
+    } catch (error) {
+      console.error('Redis DEL 错误:', error);
+      return false;
+    }
+  }
+
+  async delPattern(pattern) {
+    if (!this.isConnected) return false;
+    
+    try {
+      const keys = await this.client.keys(pattern);
+      if (keys.length > 0) {
+        await this.client.del(keys);
+      }
+      return true;
+    } catch (error) {
+      console.error('Redis DEL PATTERN 错误:', error);
+      return false;
+    }
+  }
+
+  async exists(key) {
+    if (!this.isConnected) return false;
+    
+    try {
+      return await this.client.exists(key);
+    } catch (error) {
+      console.error('Redis EXISTS 错误:', error);
+      return false;
+    }
+  }
+
+  async increment(key, ttl = 3600) {
+    if (!this.isConnected) return 0;
+    
+    try {
+      const value = await this.client.incr(key);
+      if (value === 1) {
+        await this.client.expire(key, ttl);
+      }
+      return value;
+    } catch (error) {
+      console.error('Redis INCR 错误:', error);
+      return 0;
+    }
+  }
+
+  // 缓存用户信息
+  async cacheUser(userId, userData, ttl = 600) {
+    return await this.set(`user:${userId}`, userData, ttl);
+  }
+
+  async getCachedUser(userId) {
+    return await this.get(`user:${userId}`);
+  }
+
+  async invalidateUser(userId) {
+    return await this.del(`user:${userId}`);
+  }
+
+  // 缓存群组列表
+  async cacheGroupList(userId, groups, ttl = 300) {
+    return await this.set(`groups:user:${userId}`, groups, ttl);
+  }
+
+  async getCachedGroupList(userId) {
+    return await this.get(`groups:user:${userId}`);
+  }
+
+  async invalidateGroupList(userId) {
+    return await this.del(`groups:user:${userId}`);
+  }
+
+  // 缓存群组详情
+  async cacheGroup(groupId, groupData, ttl = 300) {
+    return await this.set(`group:${groupId}`, groupData, ttl);
+  }
+
+  async getCachedGroup(groupId) {
+    return await this.get(`group:${groupId}`);
+  }
+
+  async invalidateGroup(groupId) {
+    await this.del(`group:${groupId}`);
+    // 同时清除相关的群组列表缓存
+    await this.delPattern(`groups:user:*`);
+  }
+
+  // 缓存文档列表
+  async cacheDocumentList(groupId, documents, ttl = 300) {
+    return await this.set(`documents:group:${groupId}`, documents, ttl);
+  }
+
+  async getCachedDocumentList(groupId) {
+    return await this.get(`documents:group:${groupId}`);
+  }
+
+  async invalidateDocumentList(groupId) {
+    return await this.del(`documents:group:${groupId}`);
+  }
+
+  // 缓存任务列表
+  async cacheTaskList(groupId, tasks, ttl = 300) {
+    return await this.set(`tasks:group:${groupId}`, tasks, ttl);
+  }
+
+  async getCachedTaskList(groupId) {
+    return await this.get(`tasks:group:${groupId}`);
+  }
+
+  async invalidateTaskList(groupId) {
+    return await this.del(`tasks:group:${groupId}`);
+  }
+
+  // 缓存用户任务
+  async cacheUserTasks(userId, tasks, ttl = 300) {
+    return await this.set(`tasks:user:${userId}`, tasks, ttl);
+  }
+
+  async getCachedUserTasks(userId) {
+    return await this.get(`tasks:user:${userId}`);
+  }
+
+  async invalidateUserTasks(userId) {
+    return await this.del(`tasks:user:${userId}`);
+  }
+
+  // 速率限制
+  async checkRateLimit(key, limit = 100, window = 60) {
+    const count = await this.increment(`ratelimit:${key}`, window);
+    return count <= limit;
+  }
+
+  async disconnect() {
+    if (this.client && this.isConnected) {
+      await this.client.quit();
+      console.log('👋 Redis 连接已关闭');
+    }
+  }
+}
+
+export default new CacheService();
+
+