Upload 19 files

Dockerfile

@@ -0,0 +1,23 @@
+FROM node:18-alpine
+
+# 创建工作目录
+WORKDIR /app
+
+# 复制 package.json 和 package-lock.json
+COPY package*.json ./
+
+# 安装依赖
+RUN npm install --production
+
+# 复制所有项目文件
+COPY . .
+
+# 暴露端口
+EXPOSE 8080
+
+# 设置环境变量
+ENV PORT=8080
+ENV NODE_ENV=production
+
+# 启动应用
+CMD ["npm", "start"]

config/auth.js

@@ -0,0 +1,12 @@
+const jwt = require('jsonwebtoken');
+
+// 生成 JWT Token
+const generateToken = (userId) => {
+  return jwt.sign(
+    { id: userId },
+    process.env.JWT_SECRET,
+    { expiresIn: process.env.JWT_EXPIRE || '24h' }
+  );
+};
+
+module.exports = { generateToken };

config/db.js

@@ -0,0 +1,71 @@
+const mongoose = require('mongoose');
+const logger = require('../utils/logger');
+
+const connectDB = async () => {
+  try {
+    const conn = await mongoose.connect(process.env.MONGODB_URI, {
+      useNewUrlParser: true,
+      useUnifiedTopology: true,
+    });
+
+    logger.info(`MongoDB Connected: ${conn.connection.host}`);
+    
+    // 创建默认管理员用户和默认分类
+    await createDefaultAdmin();
+    await createDefaultCategories();
+  } catch (error) {
+    logger.error(`Error connecting to MongoDB: ${error.message}`);
+    process.exit(1);
+  }
+};
+
+const createDefaultAdmin = async () => {
+  try {
+    const User = require('../models/User');
+    const bcrypt = require('bcryptjs');
+
+    // 检查是否已存在管理员用户
+    const adminExists = await User.findOne({ username: process.env.ADMIN_USERNAME });
+    
+    if (!adminExists && process.env.ADMIN_USERNAME && process.env.ADMIN_PASSWORD) {
+      // 创建管理员用户
+      const hashedPassword = await bcrypt.hash(process.env.ADMIN_PASSWORD, 10);
+      
+      await User.create({
+        username: process.env.ADMIN_USERNAME,
+        password: hashedPassword,
+        isAdmin: true
+      });
+      
+      logger.info('Default admin user created');
+    }
+  } catch (error) {
+    logger.error(`Error creating default admin: ${error.message}`);
+  }
+};
+
+const createDefaultCategories = async () => {
+  try {
+    const Category = require('../models/Category');
+    
+    // 检查是否已有分类
+    const categoriesCount = await Category.countDocuments();
+    
+    if (categoriesCount === 0) {
+      // 创建默认分类
+      const defaultCategories = [
+        { name: '通用', color: '#007AFF' },
+        { name: '工作', color: '#FF9500' },
+        { name: '学习', color: '#4CD964' },
+        { name: '创意', color: '#FF2D55' }
+      ];
+      
+      await Category.insertMany(defaultCategories);
+      logger.info('Default categories created');
+    }
+  } catch (error) {
+    logger.error(`Error creating default categories: ${error.message}`);
+  }
+};
+
+module.exports = { connectDB };

controllers/authController.js

@@ -0,0 +1,83 @@
+const asyncHandler = require('express-async-handler');
+const User = require('../models/User');
+const { generateToken } = require('../config/auth');
+
+// @desc    用户注册
+// @route   POST /api/auth/register
+// @access  Public
+const registerUser = asyncHandler(async (req, res) => {
+  const { username, password } = req.body;
+
+  // 检查用户是否已存在
+  const userExists = await User.findOne({ username });
+
+  if (userExists) {
+    res.status(400);
+    throw new Error('用户已存在');
+  }
+
+  // 创建用户
+  const user = await User.create({
+    username,
+    password,
+  });
+
+  if (user) {
+    res.status(201).json({
+      _id: user._id,
+      username: user.username,
+      isAdmin: user.isAdmin,
+      token: generateToken(user._id),
+    });
+  } else {
+    res.status(400);
+    throw new Error('无效的用户数据');
+  }
+});
+
+// @desc    用户登录
+// @route   POST /api/auth/login
+// @access  Public
+const loginUser = asyncHandler(async (req, res) => {
+  const { username, password } = req.body;
+
+  // 查找用户
+  const user = await User.findOne({ username });
+
+  // 检查用户和密码
+  if (user && (await user.matchPassword(password))) {
+    res.json({
+      _id: user._id,
+      username: user.username,
+      isAdmin: user.isAdmin,
+      token: generateToken(user._id),
+    });
+  } else {
+    res.status(401);
+    throw new Error('用户名或密码错误');
+  }
+});
+
+// @desc    获取当前用户资料
+// @route   GET /api/auth/profile
+// @access  Private
+const getUserProfile = asyncHandler(async (req, res) => {
+  const user = await User.findById(req.user._id).select('-password');
+
+  if (user) {
+    res.json({
+      _id: user._id,
+      username: user.username,
+      isAdmin: user.isAdmin,
+    });
+  } else {
+    res.status(404);
+    throw new Error('用户未找到');
+  }
+});
+
+module.exports = {
+  registerUser,
+  loginUser,
+  getUserProfile,
+};

controllers/categoryController.js

@@ -0,0 +1,113 @@
+const asyncHandler = require('express-async-handler');
+const Category = require('../models/Category');
+const PromptGroup = require('../models/PromptGroup');
+
+// @desc    获取所有分类
+// @route   GET /api/categories
+// @access  Private
+const getCategories = asyncHandler(async (req, res) => {
+  const categories = await Category.find({}).sort({ name: 1 });
+  res.json(categories);
+});
+
+// @desc    通过ID获取分类
+// @route   GET /api/categories/:id
+// @access  Private
+const getCategoryById = asyncHandler(async (req, res) => {
+  const category = await Category.findById(req.params.id);
+
+  if (category) {
+    res.json(category);
+  } else {
+    res.status(404);
+    throw new Error('分类未找到');
+  }
+});
+
+// @desc    创建分类
+// @route   POST /api/categories
+// @access  Private
+const createCategory = asyncHandler(async (req, res) => {
+  const { name, color } = req.body;
+
+  // 检查是否分类名称已存在
+  const categoryExists = await Category.findOne({ name });
+
+  if (categoryExists) {
+    res.status(400);
+    throw new Error('分类名称已存在');
+  }
+
+  const category = await Category.create({
+    name,
+    color: color || '#007AFF',
+  });
+
+  if (category) {
+    res.status(201).json(category);
+  } else {
+    res.status(400);
+    throw new Error('无效的分类数据');
+  }
+});
+
+// @desc    更新分类
+// @route   PUT /api/categories/:id
+// @access  Private
+const updateCategory = asyncHandler(async (req, res) => {
+  const { name, color } = req.body;
+
+  const category = await Category.findById(req.params.id);
+
+  if (category) {
+    // 如果更改了名称，检查新名称是否已存在
+    if (name && name !== category.name) {
+      const categoryExists = await Category.findOne({ name });
+
+      if (categoryExists) {
+        res.status(400);
+        throw new Error('分类名称已存在');
+      }
+    }
+
+    category.name = name || category.name;
+    category.color = color || category.color;
+
+    const updatedCategory = await category.save();
+    res.json(updatedCategory);
+  } else {
+    res.status(404);
+    throw new Error('分类未找到');
+  }
+});
+
+// @desc    删除分类
+// @route   DELETE /api/categories/:id
+// @access  Private
+const deleteCategory = asyncHandler(async (req, res) => {
+  const category = await Category.findById(req.params.id);
+
+  if (!category) {
+    res.status(404);
+    throw new Error('分类未找到');
+  }
+
+  // 检查是否有提示词组使用该分类
+  const groupsUsingCategory = await PromptGroup.countDocuments({ category: req.params.id });
+
+  if (groupsUsingCategory > 0) {
+    res.status(400);
+    throw new Error(`无法删除分类，有 ${groupsUsingCategory} 个提示词组正在使用它`);
+  }
+
+  await category.deleteOne();
+  res.json({ message: '分类已删除' });
+});
+
+module.exports = {
+  getCategories,
+  getCategoryById,
+  createCategory,
+  updateCategory,
+  deleteCategory,
+};

controllers/promptGroupController.js

@@ -0,0 +1,246 @@
+const asyncHandler = require('express-async-handler');
+const PromptGroup = require('../models/PromptGroup');
+
+// @desc    获取所有提示词组
+// @route   GET /api/prompt-groups
+// @access  Private
+const getPromptGroups = asyncHandler(async (req, res) => {
+  const promptGroups = await PromptGroup.find({})
+    .populate('category', 'name color')
+    .sort({ updatedAt: -1 });
+  
+  res.json(promptGroups);
+});
+
+// @desc    获取单个提示词组
+// @route   GET /api/prompt-groups/:id
+// @access  Private
+const getPromptGroupById = asyncHandler(async (req, res) => {
+  const promptGroup = await PromptGroup.findById(req.params.id)
+    .populate('category', 'name color');
+
+  if (promptGroup) {
+    res.json(promptGroup);
+  } else {
+    res.status(404);
+    throw new Error('提示词组未找到');
+  }
+});
+
+// @desc    创建提示词组
+// @route   POST /api/prompt-groups
+// @access  Private
+const createPromptGroup = asyncHandler(async (req, res) => {
+  const { name, description, category } = req.body;
+
+  const promptGroup = await PromptGroup.create({
+    name,
+    description,
+    category,
+    prompts: [],
+    workflows: [],
+    dslFiles: [],
+    createdBy: req.user._id,
+  });
+
+  if (promptGroup) {
+    res.status(201).json(promptGroup);
+  } else {
+    res.status(400);
+    throw new Error('无效的提示词组数据');
+  }
+});
+
+// @desc    更新提示词组
+// @route   PUT /api/prompt-groups/:id
+// @access  Private
+const updatePromptGroup = asyncHandler(async (req, res) => {
+  const { name, description, category } = req.body;
+
+  const promptGroup = await PromptGroup.findById(req.params.id);
+
+  if (promptGroup) {
+    promptGroup.name = name || promptGroup.name;
+    promptGroup.description = description || promptGroup.description;
+    promptGroup.category = category || promptGroup.category;
+
+    const updatedPromptGroup = await promptGroup.save();
+    res.json(updatedPromptGroup);
+  } else {
+    res.status(404);
+    throw new Error('提示词组未找到');
+  }
+});
+
+// @desc    删除提示词组
+// @route   DELETE /api/prompt-groups/:id
+// @access  Private
+const deletePromptGroup = asyncHandler(async (req, res) => {
+  const promptGroup = await PromptGroup.findById(req.params.id);
+
+  if (promptGroup) {
+    await promptGroup.deleteOne();
+    res.json({ message: '提示词组已删除' });
+  } else {
+    res.status(404);
+    throw new Error('提示词组未找到');
+  }
+});
+
+// @desc    添加提示词到提示词组
+// @route   POST /api/prompt-groups/:id/prompts
+// @access  Private
+const addPromptToGroup = asyncHandler(async (req, res) => {
+  const { title, content, tags } = req.body;
+
+  const promptGroup = await PromptGroup.findById(req.params.id);
+
+  if (promptGroup) {
+    const newPrompt = {
+      title,
+      content,
+      tags: tags || [],
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+
+    promptGroup.prompts.push(newPrompt);
+    promptGroup.updatedAt = new Date();
+
+    const updatedPromptGroup = await promptGroup.save();
+    res.status(201).json(updatedPromptGroup.prompts[updatedPromptGroup.prompts.length - 1]);
+  } else {
+    res.status(404);
+    throw new Error('提示词组未找到');
+  }
+});
+
+// @desc    更新提示词
+// @route   PUT /api/prompt-groups/:id/prompts/:promptId
+// @access  Private
+const updatePrompt = asyncHandler(async (req, res) => {
+  const { title, content, tags } = req.body;
+
+  const promptGroup = await PromptGroup.findById(req.params.id);
+
+  if (promptGroup) {
+    const promptIndex = promptGroup.prompts.findIndex(
+      (p) => p._id.toString() === req.params.promptId
+    );
+
+    if (promptIndex !== -1) {
+      promptGroup.prompts[promptIndex].title = title || promptGroup.prompts[promptIndex].title;
+      promptGroup.prompts[promptIndex].content = content || promptGroup.prompts[promptIndex].content;
+      promptGroup.prompts[promptIndex].tags = tags || promptGroup.prompts[promptIndex].tags;
+      promptGroup.prompts[promptIndex].updatedAt = new Date();
+      promptGroup.updatedAt = new Date();
+
+      const updatedPromptGroup = await promptGroup.save();
+      res.json(updatedPromptGroup.prompts[promptIndex]);
+    } else {
+      res.status(404);
+      throw new Error('提示词未找到');
+    }
+  } else {
+    res.status(404);
+    throw new Error('提示词组未找到');
+  }
+});
+
+// @desc    删除提示词
+// @route   DELETE /api/prompt-groups/:id/prompts/:promptId
+// @access  Private
+const deletePrompt = asyncHandler(async (req, res) => {
+  const promptGroup = await PromptGroup.findById(req.params.id);
+
+  if (promptGroup) {
+    const promptExists = promptGroup.prompts.some(
+      (p) => p._id.toString() === req.params.promptId
+    );
+
+    if (promptExists) {
+      promptGroup.prompts = promptGroup.prompts.filter(
+        (p) => p._id.toString() !== req.params.promptId
+      );
+      promptGroup.updatedAt = new Date();
+
+      await promptGroup.save();
+      res.json({ message: '提示词已删除' });
+    } else {
+      res.status(404);
+      throw new Error('提示词未找到');
+    }
+  } else {
+    res.status(404);
+    throw new Error('提示词组未找到');
+  }
+});
+
+// @desc    添加DSL文件到提示词组
+// @route   POST /api/prompt-groups/:id/dsl-files
+// @access  Private
+const addDslFileToGroup = asyncHandler(async (req, res) => {
+  const { name, fileData, mimeType } = req.body;
+
+  const promptGroup = await PromptGroup.findById(req.params.id);
+
+  if (promptGroup) {
+    const newDslFile = {
+      name,
+      fileData,
+      mimeType: mimeType || 'application/octet-stream',
+      uploadedAt: new Date(),
+    };
+
+    promptGroup.dslFiles.push(newDslFile);
+    promptGroup.updatedAt = new Date();
+
+    const updatedPromptGroup = await promptGroup.save();
+    res.status(201).json(updatedPromptGroup.dslFiles[updatedPromptGroup.dslFiles.length - 1]);
+  } else {
+    res.status(404);
+    throw new Error('提示词组未找到');
+  }
+});
+
+// @desc    删除DSL文件
+// @route   DELETE /api/prompt-groups/:id/dsl-files/:fileId
+// @access  Private
+const deleteDslFile = asyncHandler(async (req, res) => {
+  const promptGroup = await PromptGroup.findById(req.params.id);
+
+  if (promptGroup) {
+    const fileExists = promptGroup.dslFiles.some(
+      (f) => f._id.toString() === req.params.fileId
+    );
+
+    if (fileExists) {
+      promptGroup.dslFiles = promptGroup.dslFiles.filter(
+        (f) => f._id.toString() !== req.params.fileId
+      );
+      promptGroup.updatedAt = new Date();
+
+      await promptGroup.save();
+      res.json({ message: 'DSL文件已删除' });
+    } else {
+      res.status(404);
+      throw new Error('DSL文件未找到');
+    }
+  } else {
+    res.status(404);
+    throw new Error('提示词组未找到');
+  }
+});
+
+module.exports = {
+  getPromptGroups,
+  getPromptGroupById,
+  createPromptGroup,
+  updatePromptGroup,
+  deletePromptGroup,
+  addPromptToGroup,
+  updatePrompt,
+  deletePrompt,
+  addDslFileToGroup,
+  deleteDslFile,
+};

middleware/auth.js

@@ -0,0 +1,49 @@
+const jwt = require('jsonwebtoken');
+const asyncHandler = require('express-async-handler');
+const User = require('../models/User');
+
+// 保护路由 - 验证 JWT Token
+const protect = asyncHandler(async (req, res, next) => {
+  let token;
+
+  // 从 Authorization 头获取 token
+  if (req.headers.authorization && req.headers.authorization.startsWith('Bearer')) {
+    try {
+      // 获取 token
+      token = req.headers.authorization.split(' ')[1];
+
+      // 验证 token
+      const decoded = jwt.verify(token, process.env.JWT_SECRET);
+
+      // 获取用户并添加到请求对象中，不包含密码
+      req.user = await User.findById(decoded.id).select('-password');
+
+      if (!req.user) {
+        res.status(401);
+        throw new Error('未授权，用户不存在');
+      }
+
+      next();
+    } catch (error) {
+      res.status(401);
+      throw new Error('未授权，token 无效');
+    }
+  }
+
+  if (!token) {
+    res.status(401);
+    throw new Error('未授权，未提供 token');
+  }
+});
+
+// 限制仅管理员访问
+const admin = (req, res, next) => {
+  if (req.user && req.user.isAdmin) {
+    next();
+  } else {
+    res.status(403);
+    throw new Error('未授权，仅管理员可访问');
+  }
+};
+
+module.exports = { protect, admin };

middleware/errorHandler.js

@@ -0,0 +1,16 @@
+const logger = require('../utils/logger');
+
+const errorHandler = (err, req, res, next) => {
+  // 日志记录错误
+  logger.error(`${err.message} - ${req.originalUrl} - ${req.method}`);
+
+  const statusCode = res.statusCode === 200 ? 500 : res.statusCode;
+  
+  res.status(statusCode);
+  res.json({
+    message: err.message,
+    stack: process.env.NODE_ENV === 'production' ? null : err.stack,
+  });
+};
+
+module.exports = { errorHandler };

models/Category.js

@@ -0,0 +1,23 @@
+const mongoose = require('mongoose');
+
+const categorySchema = new mongoose.Schema(
+  {
+    name: {
+      type: String,
+      required: [true, '请输入分类名称'],
+      trim: true,
+      unique: true,
+    },
+    color: {
+      type: String,
+      default: '#007AFF',
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+const Category = mongoose.model('Category', categorySchema);
+
+module.exports = Category;

models/PromptGroup.js

@@ -0,0 +1,81 @@
+const mongoose = require('mongoose');
+
+// 提示词 Schema
+const promptSchema = new mongoose.Schema(
+  {
+    title: {
+      type: String,
+      required: [true, '请输入提示词标题'],
+      trim: true,
+    },
+    content: {
+      type: String,
+      required: [true, '请输入提示词内容'],
+    },
+    tags: [String],
+    createdAt: {
+      type: Date,
+      default: Date.now,
+    },
+    updatedAt: {
+      type: Date,
+      default: Date.now,
+    },
+  }
+);
+
+// DSL 文件 Schema
+const dslFileSchema = new mongoose.Schema(
+  {
+    name: {
+      type: String,
+      required: [true, '请输入文件名称'],
+      trim: true,
+    },
+    fileData: {
+      type: String,
+      required: [true, '请提供文件数据'],
+    },
+    mimeType: {
+      type: String,
+      default: 'application/octet-stream',
+    },
+    uploadedAt: {
+      type: Date,
+      default: Date.now,
+    },
+  }
+);
+
+// 提示词组 Schema
+const promptGroupSchema = new mongoose.Schema(
+  {
+    name: {
+      type: String,
+      required: [true, '请输入提示词组名称'],
+      trim: true,
+    },
+    description: {
+      type: String,
+      trim: true,
+    },
+    category: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'Category',
+    },
+    prompts: [promptSchema],
+    workflows: [String],
+    dslFiles: [dslFileSchema],
+    createdBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'User',
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+const PromptGroup = mongoose.model('PromptGroup', promptGroupSchema);
+
+module.exports = PromptGroup;

models/User.js

@@ -0,0 +1,44 @@
+const mongoose = require('mongoose');
+const bcrypt = require('bcryptjs');
+
+const userSchema = new mongoose.Schema(
+  {
+    username: {
+      type: String,
+      required: [true, '请输入用户名'],
+      unique: true,
+      trim: true,
+    },
+    password: {
+      type: String,
+      required: [true, '请输入密码'],
+      minlength: [6, '密码长度不能小于6个字符'],
+    },
+    isAdmin: {
+      type: Boolean,
+      default: false,
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+// 密码匹配方法
+userSchema.methods.matchPassword = async function (enteredPassword) {
+  return await bcrypt.compare(enteredPassword, this.password);
+};
+
+// 保存前加密密码
+userSchema.pre('save', async function (next) {
+  if (!this.isModified('password')) {
+    next();
+  }
+
+  const salt = await bcrypt.genSalt(10);
+  this.password = await bcrypt.hash(this.password, salt);
+});
+
+const User = mongoose.model('User', userSchema);
+
+module.exports = User;

package.json

@@ -0,0 +1,29 @@
+{
+  "name": "prompt-manager-backend",
+  "version": "1.0.0",
+  "description": "Backend for Prompt Manager application",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js",
+    "dev": "nodemon server.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "bcryptjs": "^2.4.3",
+    "cors": "^2.8.5",
+    "dotenv": "^16.0.3",
+    "express": "^4.18.2",
+    "express-async-handler": "^1.2.0",
+    "joi": "^17.9.2",
+    "jsonwebtoken": "^9.0.0",
+    "mongoose": "^7.2.0",
+    "morgan": "^1.10.0",
+    "winston": "^3.8.2"
+  },
+  "devDependencies": {
+    "nodemon": "^2.0.22"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

routes/authRoutes.js

@@ -0,0 +1,15 @@
+const express = require('express');
+const router = express.Router();
+const { registerUser, loginUser, getUserProfile } = require('../controllers/authController');
+const { protect, admin } = require('../middleware/auth');
+
+// 用户注册
+router.post('/register', protect, admin, registerUser);
+
+// 用户登录
+router.post('/login', loginUser);
+
+// 获取用户资料
+router.get('/profile', protect, getUserProfile);
+
+module.exports = router;

routes/categoryRoutes.js

@@ -0,0 +1,21 @@
+const express = require('express');
+const router = express.Router();
+const {
+  getCategories,
+  getCategoryById,
+  createCategory,
+  updateCategory,
+  deleteCategory,
+} = require('../controllers/categoryController');
+const { protect } = require('../middleware/auth');
+
+router.route('/')
+  .get(protect, getCategories)
+  .post(protect, createCategory);
+
+router.route('/:id')
+  .get(protect, getCategoryById)
+  .put(protect, updateCategory)
+  .delete(protect, deleteCategory);
+
+module.exports = router;

routes/index.js

@@ -0,0 +1,12 @@
+const express = require('express');
+const router = express.Router();
+const authRoutes = require('./authRoutes');
+const promptGroupRoutes = require('./promptGroupRoutes');
+const categoryRoutes = require('./categoryRoutes');
+
+// 注册路由
+router.use('/auth', authRoutes);
+router.use('/prompt-groups', promptGroupRoutes);
+router.use('/categories', categoryRoutes);
+
+module.exports = router;

routes/promptGroupRoutes.js

@@ -0,0 +1,42 @@
+const express = require('express');
+const router = express.Router();
+const {
+  getPromptGroups,
+  getPromptGroupById,
+  createPromptGroup,
+  updatePromptGroup,
+  deletePromptGroup,
+  addPromptToGroup,
+  updatePrompt,
+  deletePrompt,
+  addDslFileToGroup,
+  deleteDslFile,
+} = require('../controllers/promptGroupController');
+const { protect } = require('../middleware/auth');
+
+// 提示词组路由
+router.route('/')
+  .get(protect, getPromptGroups)
+  .post(protect, createPromptGroup);
+
+router.route('/:id')
+  .get(protect, getPromptGroupById)
+  .put(protect, updatePromptGroup)
+  .delete(protect, deletePromptGroup);
+
+// 提示词路由
+router.route('/:id/prompts')
+  .post(protect, addPromptToGroup);
+
+router.route('/:id/prompts/:promptId')
+  .put(protect, updatePrompt)
+  .delete(protect, deletePrompt);
+
+// DSL文件路由
+router.route('/:id/dsl-files')
+  .post(protect, addDslFileToGroup);
+
+router.route('/:id/dsl-files/:fileId')
+  .delete(protect, deleteDslFile);
+
+module.exports = router;

server.js

@@ -0,0 +1,56 @@
+const express = require('express');
+const dotenv = require('dotenv');
+const cors = require('cors');
+const morgan = require('morgan');
+const { connectDB } = require('./config/db');
+const { errorHandler } = require('./middleware/errorHandler');
+const routes = require('./routes');
+const logger = require('./utils/logger');
+
+// 加载环境变量
+dotenv.config();
+
+// 初始化 Express 应用
+const app = express();
+
+// 中间件
+app.use(cors());
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+// 日志中间件
+if (process.env.NODE_ENV === 'development') {
+  app.use(morgan('dev'));
+}
+
+// 连接数据库
+connectDB();
+
+// 路由
+app.use('/api', routes);
+
+// 健康检查端点
+app.get('/health', (req, res) => {
+  res.status(200).json({ status: 'ok', message: 'Server is running' });
+});
+
+// 错误处理中间件
+app.use(errorHandler);
+
+// 启动服务器
+const PORT = process.env.PORT || 8080;
+app.listen(PORT, () => {
+  logger.info(`Server running in ${process.env.NODE_ENV} mode on port ${PORT}`);
+});
+
+// 处理未捕获的异常
+process.on('uncaughtException', (err) => {
+  logger.error('Uncaught Exception:', err);
+  process.exit(1);
+});
+
+// 处理未处理的 Promise 拒绝
+process.on('unhandledRejection', (err) => {
+  logger.error('Unhandled Rejection:', err);
+  process.exit(1);
+});

utils/logger.js

@@ -0,0 +1,35 @@
+const winston = require('winston');
+
+// 定义日志格式
+const logger = winston.createLogger({
+  level: process.env.NODE_ENV === 'development' ? 'debug' : 'info',
+  format: winston.format.combine(
+    winston.format.timestamp({
+      format: 'YYYY-MM-DD HH:mm:ss',
+    }),
+    winston.format.errors({ stack: true }),
+    winston.format.splat(),
+    winston.format.json()
+  ),
+  defaultMeta: { service: 'prompt-manager-api' },
+  transports: [
+    new winston.transports.Console({
+      format: winston.format.combine(
+        winston.format.colorize(),
+        winston.format.printf(
+          (info) => `${info.timestamp} ${info.level}: ${info.message}`
+        )
+      ),
+    }),
+  ],
+});
+
+// 如果是生产环境，记录到文件
+if (process.env.NODE_ENV === 'production') {
+  logger.add(
+    new winston.transports.File({ filename: 'logs/error.log', level: 'error' })
+  );
+  logger.add(new winston.transports.File({ filename: 'logs/combined.log' }));
+}
+
+module.exports = logger;

utils/validators.js

@@ -0,0 +1,42 @@
+const Joi = require('joi');
+
+// 用户验证模式
+const userSchema = Joi.object({
+  username: Joi.string().required().min(3).max(30),
+  password: Joi.string().required().min(6),
+});
+
+// 分类验证模式
+const categorySchema = Joi.object({
+  name: Joi.string().required().min(1).max(30),
+  color: Joi.string().pattern(new RegExp('^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$')),
+});
+
+// 提示词验证模式
+const promptSchema = Joi.object({
+  title: Joi.string().required().min(1).max(100),
+  content: Joi.string().required(),
+  tags: Joi.array().items(Joi.string()),
+});
+
+// 提示词组验证模式
+const promptGroupSchema = Joi.object({
+  name: Joi.string().required().min(1).max(100),
+  description: Joi.string().allow('', null),
+  category: Joi.string().pattern(new RegExp('^[0-9a-fA-F]{24}$')),
+});
+
+// DSL文件验证模式
+const dslFileSchema = Joi.object({
+  name: Joi.string().required(),
+  fileData: Joi.string().required(),
+  mimeType: Joi.string(),
+});
+
+module.exports = {
+  userSchema,
+  categorySchema,
+  promptSchema,
+  promptGroupSchema,
+  dslFileSchema,
+};