streamline-code-by-ikun2274 0.11.1

package/Develop-log.md

@@ -0,0 +1,47 @@
+###  更新时间- 2026.4.4 12：00   
+#### 当前版本是  0.11.1
+
+```
+//1. 单个中间件
+
+DefineRoutePlus_A({
+  url: '/api/products',
+  method: 'get',
+  BuiltinMid: {
+    Parameter: 'requireAuth'
+  },
+  PlusHandler: {
+    db: { table: 'products', operation: 'read' },
+    other: { successMessage: '获取商品列表成功' }
+  }
+});
+
+//带参数的中间件
+DefineRoutePlus_A({
+  url: '/api/products',
+  method: 'get',
+  BuiltinMid: {
+    Parameter: 'pagination:20' // 分页，每页20条
+  },
+  PlusHandler: {
+    db: { table: 'products', operation: 'read' },
+    other: { successMessage: '获取商品列表成功' }
+  }
+});
+
+//多个中间件
+DefineRoutePlus_A({
+  url: '/api/products',
+  method: 'get',
+  BuiltinMid: {
+    Parameter: ['requireAuth', 'pagination:20', 'shuffle']
+  },
+  PlusHandler: {
+    db: { table: 'products', operation: 'read' },
+    other: { successMessage: '获取商品列表成功' }
+  }
+});
+```
+
+###  松烟迭代了当前项目的  字符串正则匹配字符串，通过这个激活中间件，你可以按需要搭配我的内置中间件了
+ --  想迭代为express 生态  gitee仓库 10k star的第一天

package/Example.js

@@ -0,0 +1,100 @@
+import { setDbConfig,startServer,DefineRoutePlus_A } from './src/StreamlineCodeIndex.js';
+
+
+
+
+setDbConfig({
+    /**
+     * 
+     *   host: 'your-host',
+  user: 'your-username',
+  password: 'your-password',
+  database: 'your-database'
+     * 
+     */
+
+    host: 'localhost',
+    user: 'root', // 你的 MySQL 用户名
+    password: '123456', // 你的 MySQL 密码
+    database: 'my_test_db' // 数据库名
+
+})
+
+
+startServer({
+  port: 8008, // 端口配置
+  allowedOrigins: [ // 允许的域名
+    'http://127.0.0.1:5501',
+    'http://ztgame.click',
+    'http://60.205.158.63',
+    'http://localhost:5173'
+  ]
+});
+
+
+DefineRoutePlus_A({
+    
+/**
+ * 二次封装 defineRoute 函数
+ *  {Object} options - 路由配置选项
+ * {string} options.url    - 路由路径（必填）
+ *  {string} options.method - HTTP 方法（GET/POST/PUT/DELETE，必填）
+ *  {Array<Function>} [options.middlewares=[]] - 中间件数组（可选）
+ *  {Function} options.handler - 业务逻辑处理函数（async (req) => data，必填）
+ * {Object} options.PlusHandler - 额外处理选项（必填）
+ *  {Object} options.PlusHandler.db - 数据库操作（必填）select/insert/update/update/delete
+ * {string} options.PlusHandler.db.table - 数据库表名（必填）
+ *  {string} options.PlusHandler.db.operation - 数据库操作（必填）
+ *  {string} [options.PlusHandler.db.primaryKey='id'] - 主键字段（可选）
+ * {string} [options.PlusHandler.db.fields='*'] - 查询字段（可选）
+ * {string} [options.PlusHandler.db.categoryField='category_id'] - 分类字段（可选）
+ *  {Object} options.PlusHandler.Mode - 模式选项（必填）
+ *  {boolean} [options.PlusHandler.Mode.pagination=false] - 是否支持分页（可选）
+ *  {boolean} [options.PlusHandler.Mode.requireAuth=false] - 是否需要身份验证（可选）
+ *  {boolean} [options.PlusHandler.Mode.shuffle=false] - 是否打乱数据（可选）
+ *  {number} [options.PlusHandler.Mode.pageSize=10] - 每页大小（可选）
+ *  {Object} options.PlusHandler.other - 其他选项（必填）
+ *  {string} [options.PlusHandler.other.successMessage='操作成功'] - 成功消息（可选）
+ *  {string} [options.PlusHandler.other.errorMessage='操作失败'] - 错误消息（可选）
+ * */
+
+    
+    url: '/api/productlist',
+    //请求方法
+    method: 'get',
+    //内置方法
+    PlusHandler: {
+        //数据表操作
+        db: {
+            table: 'product',
+            operation: 'select',//select/insert/update/update/delete
+            primaryKey: 'id',
+            fields: '*',
+        },
+        Mode: {
+            pagination: true,
+            requireAuth: false,
+            shuffle: false,
+            pageSize: 10
+
+        },
+        //其他
+        other: {
+            successMessage: '操作成功',
+            errorMessage: '操作失败'
+        }
+    }
+
+
+
+    /**
+     * 
+     * 
+     * 
+     */
+});
+
+
+
+
+

package/README.md

@@ -0,0 +1,126 @@
+## 项目介绍 express-lowcode-by-ikun2274
+
+
+## 开发日志
+详细的开发历程和版本更新记录，请查看 [开发日志](Develop-log.md)。
+
+
+### 基本介绍
+
+```
+express-lowcode-by-ikun2274 是一个基于 Express 的低代码路由构建工具，
+用于快速构建数据库操作、分页、认证等路由。
+```
+
+
+
+
+
+##  npm的地址
+
+```
+https://www.npmjs.com/package/express-lowcode-by-ikun2274
+```
+
+### 示例代码-
+
+```
+你可以在npm安装之后  有一个叫做Example.js的文件  它是一个示例代码  
+你可以参考它来快速构建自己的路由 之后我自己会在项目里面塞上示例代码文件夹的  
+
+你可以这样子写 Example.js是这样子的
+
+
+import { setDbConfig,startServer,DefineRoutePlus_A } from './src/LowCodeIndex.js';
+
+
+
+
+setDbConfig({
+    /**
+     * 
+     *   host: 'your-host',
+  user: 'your-username',
+  password: 'your-password',
+  database: 'your-database'
+     * 
+     */
+
+    host: 'localhost',
+    user: 'root', // 你的 MySQL 用户名
+    password: '123456', // 你的 MySQL 密码
+    database: 'my_test_db' // 数据库名
+
+})
+
+
+startServer({
+  port: 8008, // 端口配置
+  allowedOrigins: [ // 允许的域名
+    'http://127.0.0.1:5501',
+    'http://ztgame.click',
+    'http://60.205.158.63',
+    'http://localhost:5173'
+  ]
+});
+
+
+DefineRoutePlus_A({
+    
+/**
+ * 二次封装 defineRoute 函数
+ *  {Object} options - 路由配置选项
+ * {string} options.url    - 路由路径（必填）
+ *  {string} options.method - HTTP 方法（GET/POST/PUT/DELETE，必填）
+ *  {Array<Function>} [options.middlewares=[]] - 中间件数组（可选）
+ *  {Function} options.handler - 业务逻辑处理函数（async (req) => data，必填）
+ * {Object} options.PlusHandler - 额外处理选项（必填）
+ *  {Object} options.PlusHandler.db - 数据库操作选项（必填）
+ * {string} options.PlusHandler.db.table - 数据库表名（必填）
+ *  {string} options.PlusHandler.db.operation - 数据库操作（必填）
+ *  {string} [options.PlusHandler.db.primaryKey='id'] - 主键字段（可选）
+ * {string} [options.PlusHandler.db.fields='*'] - 查询字段（可选）
+ * {string} [options.PlusHandler.db.categoryField='category_id'] - 分类字段（可选）
+ *  {Object} options.PlusHandler.Mode - 模式选项（必填）
+ *  {boolean} [options.PlusHandler.Mode.pagination=false] - 是否支持分页（可选）
+ *  {boolean} [options.PlusHandler.Mode.requireAuth=false] - 是否需要身份验证（可选）
+ *  {boolean} [options.PlusHandler.Mode.shuffle=false] - 是否打乱数据（可选）
+ *  {number} [options.PlusHandler.Mode.pageSize=10] - 每页大小（可选）
+ *  {Object} options.PlusHandler.other - 其他选项（必填）
+ *  {string} [options.PlusHandler.other.successMessage='操作成功'] - 成功消息（可选）
+ *  {string} [options.PlusHandler.other.errorMessage='操作失败'] - 错误消息（可选）
+ * */
+
+    
+    url: '/api/productlist',
+    //请求方法
+    method: 'get',
+    //内置方法
+    PlusHandler: {
+        //数据表操作
+        db: {
+        },
+        Mode: {
+        },
+        //其他
+        other: {
+        }
+    }
+
+});
+
+
+```
+
+### 安装它
+```
+npm install express-lowcode-by-ikun2274
+```
+
+
+
+### 其他
+
+```
+待迭代开发ing
+```

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "streamline-code-by-ikun2274",
+  "version": "0.11.1",
+  "description": "A streamline Express route builder with database operations, pagination, and authentication",
+  "main": "src/StreamlineCodeIndex.js",
+  "exports": {
+    ".": {
+      "import": "./src/StreamlineCodeIndex.js",
+      "type": "./types/index.d.ts"
+
+    }
+  },
+  "scripts": {
+
+  },
+  "keywords": [
+    "express",
+    "router",
+    "streamline-code",
+    "database",
+    "pagination",
+    "authentication"
+  ],
+  "author": "ikun2274",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yourusername/express-route-builder.git"
+  },
+  "dependencies": {
+    "axios": "1.13.6",
+    "body-parser": "2.2.2",
+    "cors": "2.8.5",
+    "dotenv": "17.2.3",
+    "express": "5.1.0",
+    "fs-extra": "11.3.4",
+    "jsonwebtoken": "9.0.3",
+    "mysql2": "3.19.1"
+  }
+}

package/src/Databaseope/DataIndex.js

@@ -0,0 +1 @@
+export * from './data.js';

package/src/Databaseope/data.js

@@ -0,0 +1,161 @@
+
+
+//data.js
+
+import mysql from 'mysql2/promise';
+
+
+
+// 数据库配置  模拟环境
+/*
+*/
+
+
+let dbConfig = {
+  host: 'localhost',
+  user: 'root', // 你的 MySQL 用户名
+  password: '123456', // 你的 MySQL 密码
+  database: 'my_test_db' // 数据库名
+};
+
+export function setDbConfig(config) {
+  dbConfig = { ...dbConfig, ...config };
+}
+
+
+
+
+// 数据库配置  生产环境  宝塔服务面板远程MySQL
+/**
+
+
+const dbConfig = {
+  host: '127.0.0.1', // 替换为完整的本地IP
+  user: 'Root',
+  password: 'mYGFXTY5iHkRbfJ8',
+  database: 'My_test_db'
+};
+
+ */
+
+export async function query(sql, params = []) {
+  const connection = await mysql.createConnection(dbConfig);
+  try {
+    const [rows] = await connection.execute(sql, params);
+    return rows;
+  } finally {
+    await connection.end();
+  }
+}
+
+
+
+// data.js（添加以下代码）
+class DB {
+  /**
+   * 根据条件查询单条记录
+   * @param {string} table - 表名
+   * @param {object} where - 查询条件，如 { id: 1 }
+   * @param {string[]} fields - 要查询的字段，默认 ['*']
+   * @returns {object|null} 查询结果，无结果返回 null
+   */
+  async findOne(table, where = {}, fields = ['*']) {
+    const { sql, params } = this.buildSelectSQL(table, fields, where);
+    const [result] = await query(sql, params);
+    return result || null;
+  }
+
+  /**
+   * 查询多条记录
+   * @param {string} table - 表名
+   * @param {object} where - 查询条件，如 { age: { gt: 18 } }
+   * @param {string[]} fields - 要查询的字段，默认 ['*']
+   * @param {object} options - 其他选项，如 { limit: 10, orderBy: 'id DESC' }
+   * @returns {array} 查询结果数组
+   */
+  async find(table, where = {}, fields = ['*'], options = {}) {
+    const { sql, params } = this.buildSelectSQL(table, fields, where, options);
+    return await query(sql, params);
+  }
+
+  /**
+   * 插入记录
+   * @param {string} table - 表名
+   * @param {object} data - 要插入的数据，如 { name: '张三', age: 20 }
+   * @returns {object} 插入结果，包含 insertId
+   */
+  async create(table, data) {
+    const keys = Object.keys(data);
+    const values = Object.values(data);
+    const placeholders = keys.map(() => '?').join(', ');
+    const sql = `INSERT INTO ${table} (${keys.join(', ')}) VALUES (${placeholders})`;
+    const result = await query(sql, values);
+
+    return { ...data, id: result.insertId || null };
+  }
+
+  /**
+   * 更新记录
+   * @param {string} table - 表名
+   * @param {object} data - 要更新的数据，如 { name: '李四' }
+   * @param {object} where - 更新条件，如 { id: 1 }
+   * @returns {boolean} 是否更新成功
+   */
+  async update(table, data, where) {
+    const setClause = Object.keys(data).map(key => `${key} = ?`).join(', ');
+    const values = [...Object.values(data), ...Object.values(where)];
+    const whereClause = Object.keys(where).map(key => `${key} = ?`).join(' AND ');
+    const sql = `UPDATE ${table} SET ${setClause} WHERE ${whereClause}`;
+    const [result] = await query(sql, values);
+    return result.affectedRows > 0;
+  }
+
+  /**
+   * 删除记录
+   * @param {string} table - 表名
+   * @param {object} where - 删除条件，如 { id: 1 }
+   * @returns {boolean} 是否删除成功
+   */
+  async delete(table, where) {
+    const whereClause = Object.keys(where).map(key => `${key} = ?`).join(' AND ');
+    const sql = `DELETE FROM ${table} WHERE ${whereClause}`;
+    const [result] = await query(sql, Object.values(where));
+    return result.affectedRows > 0;
+  }
+
+  // 构建 SELECT SQL 语句的辅助方法
+  buildSelectSQL(table, fields, where, options = {}) {
+    const fieldStr = fields.join(', ');
+    let sql = `SELECT ${fieldStr} FROM ${table}`;
+    const params = [];
+
+    // 处理 WHERE 条件
+    if (Object.keys(where).length > 0) {
+      const conditions = [];
+      for (const [key, value] of Object.entries(where)) {
+        conditions.push(`${key} = ?`);
+        params.push(value);
+      }
+      sql += ` WHERE ${conditions.join(' AND ')}`;
+    }
+
+    // 处理排序
+    if (options.orderBy) {
+      sql += ` ORDER BY ${options.orderBy}`;
+    }
+
+    // 处理分页
+    if (options.limit) {
+      sql += ` LIMIT ?`;
+      params.push(options.limit);
+      if (options.offset) {
+        sql += ` OFFSET ?`;
+        params.push(options.offset);
+      }
+    }
+
+    return { sql, params };
+  }
+}
+
+export const ToolDb = new DB();

package/src/Middleware/MiddleWareIndex.js

@@ -0,0 +1,3 @@
+export * from './auth/AuthIndex.js';
+export * from './data/DataIndex.js';
+export * from './response/ResponseIndex.js';

package/src/Middleware/auth/AuthIndex.js

@@ -0,0 +1,4 @@
+
+
+export * from './token.js';
+export * from './validation.js';

package/src/Middleware/auth/token.js

@@ -0,0 +1,27 @@
+import { JWT_SECRET, TOKEN_EXPIRES_IN } from '../../Other/constant.js';
+import jwt from 'jsonwebtoken';
+
+export const generateToken = (req, res, next) => {
+  const { user } = req;
+  
+  const token = jwt.sign({ userId: user.id }, JWT_SECRET, { expiresIn: TOKEN_EXPIRES_IN });
+  
+  // 将 token 存储到请求对象中，供后续中间件使用
+  req.token = token;
+  next();
+};
+
+export const verifyToken = (req, res, next) => {
+  const authHeader = req.headers.authorization;
+  if (!authHeader || !authHeader.startsWith('Bearer ')) {
+    return res.status(401).json({ code: 401, message: '请先登录（未提供 token）' });
+  }
+  const token = authHeader.split(' ')[1];
+  try {
+    const decoded = jwt.verify(token, JWT_SECRET);
+    req.user = decoded;
+    next();
+  } catch (err) {
+    return res.status(401).json({ code: 401, message: 'token 无效或已过期，请重新登录' });
+  }
+};

package/src/Middleware/auth/validation.js

@@ -0,0 +1,60 @@
+import { ToolDb } from '../../Databaseope/data.js';
+
+export const validateLogin = (req, res, next) => {
+  const { username, password } = req.body;
+  
+  if (!username || !password) {
+    return res.status(400).json({ code: 400, message: '用户名和密码不能为空' });
+  }
+  
+  next();
+};
+
+export const validateRegister = (req, res, next) => {
+  const { username, password } = req.body;
+  
+  // 校验用户名
+  if (!username) {
+    return res.status(400).json({ code: 400, Usermessage: '用户名不能为空喵~' });
+  }
+  if (username.length > 10) {
+    return res.status(400).json({ code: 400, Usermessage: '用户名不能超过10个字符喵~' });
+  }
+  
+  // 校验密码
+  const passwordReg = /^\d{4,8}$/;
+  if (!password) {
+    return res.status(400).json({ code: 400, Passwordmessage: '密码不能为空喵~' });
+  }
+  if (!passwordReg.test(password)) {
+    return res.status(400).json({ code: 400, Passwordmessage: '密码必须是4-8位数字组成喵~' });
+  }
+  
+  next();
+};
+
+export const checkUsername = async (req, res, next) => {
+  const { username } = req.body;
+  
+  const exist = await ToolDb.findOne('users', { username });
+  if (exist) {
+    return res.status(400).json({ code: 400, Usermessage: '用户名已存在喵~' });
+  }
+  
+  next();
+};
+
+export const verifyUser = async (req, res, next) => {
+  const { username, password } = req.body;
+  
+  const user = await ToolDb.findOne('users', { username, password }, 
+    ['id', 'username', 'password']);
+  
+  if (!user) {
+    return res.status(401).json({ code: 401, message: '账号或密码错误' });
+  }
+  
+  // 将用户信息存储到请求对象中，供后续中间件使用
+  req.user = user;
+  next();
+};

package/src/Middleware/data/DataIndex.js

@@ -0,0 +1,3 @@
+export * from './filter.js';
+export * from './pagination.js';
+export * from './utils.js';

package/src/Middleware/data/filter.js

@@ -0,0 +1,13 @@
+export const categoryFilter = (categoryField = 'category_id') => (req, res, next) => {
+  // 构建查询条件
+  const where = {};
+  // 检查是否有分类ID
+  const categoryId = req.query.categoryId;
+  if (categoryId) {
+    where[categoryField] = categoryId;
+  }
+  
+  // 将查询条件添加到请求对象中
+  req.query.where = where;
+  next();
+};

package/src/Middleware/data/pagination.js

@@ -0,0 +1,10 @@
+export const Dpagination = (defaultPageSize = 10) => (req, res, next) => {
+  // 解析分页参数
+  const page = parseInt(req.query.page) || 1;
+  const pageSize = parseInt(req.query.pageSize) || defaultPageSize;
+  const offset = (page - 1) * pageSize;
+  
+  // 将分页参数添加到请求对象中
+  req.pagination = { page, pageSize, offset };
+  next();
+};

package/src/Middleware/data/utils.js

@@ -0,0 +1,33 @@
+export const shuffleData = (req, res, next) => {
+  // Fisher-Yates 洗牌算法
+  function shuffleArray(array) {
+    for (let i = array.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [array[i], array[j]] = [array[j], array[i]];
+    }
+    return array;
+  }
+  
+  // 将洗牌函数添加到请求对象中
+  req.shuffleArray = shuffleArray;
+  next();
+};
+
+export const generateId = (table, primaryKey = 'id') => async (req, res, next) => {
+  try {
+    const ToolDb = req.db || require('../../Databaseope/data.js').ToolDb;
+    // 生成新 id
+    const records = await ToolDb.find(table);
+    const ids = Array.isArray(records)
+      ? records.map(record => record[primaryKey]).filter(id => id !== null && id !== undefined && typeof id === 'number')
+      : [];
+    const maxId = ids.length > 0 ? Math.max(...ids) : 0;
+    const newId = maxId + 1;
+    
+    // 将生成的ID添加到请求体中
+    req.body = { [primaryKey]: newId, ...req.body };
+    next();
+  } catch (error) {
+    next(error);
+  }
+};

package/src/Middleware/response/ResponseIndex.js

@@ -0,0 +1,21 @@
+export const unifiedResponse = (successMessage = '操作成功') => (req, res, next) => {
+  // 保存原始的json方法
+  const originalJson = res.json;
+  
+  // 重写json方法
+  res.json = function(data) {
+    // 如果数据已经是标准格式，直接返回
+    if (data.code !== undefined) {
+      return originalJson.call(this, data);
+    }
+    
+    // 否则，包装为标准格式
+    return originalJson.call(this, {
+      code: 200,
+      data: data,
+      message: successMessage
+    });
+  };
+  
+  next();
+};

package/src/Other/OtherIndex.js

@@ -0,0 +1 @@
+export * from './constant.js';

package/src/Other/constant.js

@@ -0,0 +1,4 @@
+export const JWT_SECRET = 'your_very_secure_secret_key_123'; // 替换成随机复杂字符串
+export const TOKEN_EXPIRES_IN = 60 * 60 * 24 * 14; // 60秒×60分×24小时×14天
+
+

package/src/Request/RequestIndex.js

@@ -0,0 +1 @@
+export * from './StreamlineCode.js';

package/src/Request/StreamlineCode.js

@@ -0,0 +1,308 @@
+import express from 'express';
+const app = express();
+import { ToolDb } from '../Databaseope/data.js';
+import {
+  validateLogin, verifyUser, generateToken,
+  validateRegister, checkUsername, verifyToken, categoryFilter, Dpagination, shuffleData, unifiedResponse
+} from '../Middleware/MiddleWareIndex.js';
+
+
+/**
+ * 二次封装 Express 路由注册
+ * @param {Object} options
+ * @param {string} options.url    - 路由路径（必填）
+ * @param {string} options.method - HTTP 方法（GET/POST/PUT/DELETE，必填）
+ * @param {Array<Function>} [options.middlewares=[]] - 中间件数组（可选）
+ * @param {Function} options.handler - 业务逻辑处理函数（async (req) => data，必填）
+ */
+
+export const defineRoute = (options) => {
+
+  const { url, method, middlewares = [], handler } = options;
+
+  // 校验参数（同上）
+  if (!url || !method || typeof handler !== 'function') {
+    throw new Error('url、method、handler 为必填项');
+  }
+
+  const httpMethod = method.toLowerCase();
+  const validMethods = ['get', 'post', 'put', 'delete'];
+  if (!validMethods.includes(httpMethod)) {
+    throw new Error(`不支持的方法：${method}`);
+  }
+
+  // 包装 handler：支持手动响应 + 自动兜底
+  const wrappedHandler = async (req, res, next) => {
+    try {
+      // 关键修改：让 handler 同时接收 req 和 res
+      const data = await handler(req, res);
+
+      // 如果没手动调用 res.json()/res.send() 等，就自动包装响应
+      if (!res.headersSent) {
+        res.status(200).json({
+          data: data || null // 用你想要的默认格式（比如 { data: ... }）
+        });
+      }
+    } catch (err) {
+      // 错误处理：如果没手动响应错误，就自动处理
+      if (!res.headersSent) {
+        const status = err.status || 500;
+        res.status(status).json({
+          message: err.message || '服务器错误',
+          error: err.message
+        });
+      }
+    }
+  };
+
+  // 注册路由
+  app[httpMethod](url, ...middlewares, wrappedHandler);
+};
+
+
+
+/**
+ * 二次封装 defineRoute 函数
+ * @param {Object} options - 路由配置选项 
+ * @param {string} options.url    - 路由路径（必填）
+ * @param {string} options.method - HTTP 方法（GET/POST/PUT/DELETE，必填）
+ * @param {Array<Function>} [options.middlewares=[]] - 中间件数组（可选）//看你需求  因为我尽可能集成中间件了
+ * @param {Object} options.PlusHandler - 额外处理选项（必填）
+ * @param {Object} options.PlusHandler.db - 数据库操作（必填）
+ * @param {string} options.PlusHandler.db.table - 数据库表名（必填）
+ * @param {string} options.PlusHandler.db.operation - 数据表操作（必填）select/insert/update/update/delete
+ * @param {string} [options.PlusHandler.db.primaryKey='id'] - 主键字段（可选）
+ * @param {string} [options.PlusHandler.db.fields='*'] - 查询字段（可选）
+ * @param {string} [options.PlusHandler.db.categoryField='category_id'] - 分类字段（可选）
+ * @param {Object} options.PlusHandler.Mode - 模式选项（必填）
+ * @param {boolean} [options.PlusHandler.Mode.pagination=false] - 是否支持分页（可选）
+ * @param {boolean} [options.PlusHandler.Mode.requireAuth=false] - 是否需要身份验证（可选）
+ * @param {boolean} [options.PlusHandler.Mode.shuffle=false] - 是否打乱数据（可选）
+ * @param {number} [options.PlusHandler.Mode.pageSize=10] - 每页大小（可选）
+ * @param {Object} options.PlusHandler.other - 其他选项（必填）
+ * @param {string} [options.PlusHandler.other.successMessage='操作成功'] - 成功消息（可选）
+ * @param {string} [options.PlusHandler.other.errorMessage='操作失败'] - 错误消息（可选）
+ * */
+
+export function DefineRoutePlus_A(options) {
+
+  const {
+    url,
+    method = 'get',
+    middlewares = [],
+
+    BuiltinMid = {
+      Parameter: '' || ['', ''],
+    },
+
+
+    PlusHandler: {
+      db: {
+        table,
+        operation,
+        primaryKey = 'id',
+        fields = '*',
+        categoryField = 'category_id',
+
+      },
+/**
+ *  Mode: {
+        pagination = false, // 是否支持分页
+        requireAuth = false, // 是否需要身份验证
+        validationMode = '', // 验证模式：login, register
+        shuffle = false, // 是否打乱数据
+        autoGenerateId = false, // 是否自动生成ID
+        pageSize = 10,   // 每页大小
+      },
+
+ * 
+ */
+     
+      other: {
+        customLogic = null, // 自定义逻辑函数
+        successMessage = '操作成功', // 成功消息
+        errorMessage = '操作失败', // 错误消息
+      }
+
+    }
+  } = options
+
+  // 中间件映射表
+  const middlewareMap = {
+    'requireAuth': () => verifyToken,
+    'login': () => [validateLogin, verifyUser, generateToken],
+    'register': () => [validateRegister, checkUsername],
+    'categoryFilter': (field = categoryField) => categoryFilter(field),
+    'pagination': (size = 10) => Dpagination(Number(size)),
+    'shuffle': () => shuffleData,
+    'unifiedResponse': (message = successMessage) => unifiedResponse(message)
+  };
+
+  // 构建中间件链
+  const builtInMiddlewares = [];
+
+  // 处理 BuiltinMid.Parameter
+  const parameters = Array.isArray(BuiltinMid.Parameter) ? BuiltinMid.Parameter : (BuiltinMid.Parameter ? [BuiltinMid.Parameter] : []);
+  
+  for (const param of parameters) {
+    // 使用正则表达式匹配中间件名称和参数，格式：middleware:param1:param2
+    const match = param.match(/^([a-zA-Z0-9]+)(?::([^:]+))*$/);
+    if (match) {
+      const [, name, ...params] = match;
+      if (middlewareMap[name]) {
+        const middleware = middlewareMap[name](...params);
+        // 处理返回数组的中间件（如 login, register）
+        if (Array.isArray(middleware)) {
+          builtInMiddlewares.push(...middleware);
+        } else {
+          builtInMiddlewares.push(middleware);
+        }
+      }
+    }
+  }
+
+  // 默认添加分类过滤和统一响应中间件
+  if (!parameters.some(param => param.startsWith('categoryFilter'))) {
+    builtInMiddlewares.push(categoryFilter(categoryField));
+  }
+  if (!parameters.some(param => param.startsWith('unifiedResponse'))) {
+    builtInMiddlewares.push(unifiedResponse(successMessage));
+  }
+
+
+
+
+  // 合并用户自定义中间件
+  const finalMiddlewares = [...builtInMiddlewares, ...middlewares];
+
+  const defaultHandler = async (req, res) => {
+    try {
+      let result;
+
+      // 如果有自定义逻辑，执行自定义逻辑
+      if (customLogic && typeof customLogic === 'function') {
+        // 将successMessage和errorMessage作为参数传递给customLogic
+        result = await customLogic(req, res, ToolDb, successMessage, errorMessage);
+        // 如果自定义逻辑已经发送了响应，直接返回
+        if (res.headersSent) {
+          return;
+        }
+      } else {
+        // 根据操作类型执行数据库操作
+        switch (operation) {
+
+          case 'create':
+            // 处理创建操作
+            let createData = req.body;
+
+            // 如果需要自动生成ID
+            if (autoGenerateId) {
+              // 直接使用generateId中间件的逻辑
+              const records = await ToolDb.find(table);
+              const ids = Array.isArray(records)
+                ? records.map(record => record[primaryKey])
+                  .filter(id => id !== null && id !== undefined && typeof id === 'number')
+                : [];
+              const maxId = ids.length > 0 ? Math.max(...ids) : 0;
+              const newId = maxId + 1;
+              createData = { [primaryKey]: newId, ...createData };
+            }
+
+            await ToolDb.create(table, createData);
+            break;
+
+          case 'select':
+          case 'read':
+            // 处理查询操作
+            // 从请求对象中获取查询条件（由categoryFilter中间件设置）
+            const where = req.query.where || {};
+
+            if (pagination) {
+              // 从请求对象中获取分页参数（由pagination中间件设置）
+              const { page, pageSize: size, offset } = req.pagination;
+
+              const fieldsArray = fields === '' ? ['*'] : fields.split(',');
+
+              let data = await ToolDb.find(table, where, fieldsArray, {
+                limit: size,
+                offset: offset
+              });
+
+              // 如果需要打乱数据
+              if (shuffle && req.shuffleArray) {
+                data = req.shuffleArray(data);
+              }
+
+              // 查询总数
+              const totalData = await ToolDb.find(table, where);
+              const total = totalData.length;
+              const totalPages = Math.ceil(total / size);
+
+              result = { data, pagination: { page, pageSize: size, total, totalPages } };
+            } else {
+              // 普通查询
+              const id = req.params[primaryKey];
+              if (id) {
+                // 根据 ID 查询
+                result = await ToolDb.findOne(table,
+                  { [primaryKey]: id }, fields.split(','));
+              } else {
+                // 查询所有
+                let data = await ToolDb.find(table, where, fields.split(','));
+                // 如果需要打乱数据
+                if (shuffle && req.shuffleArray) {
+                  data = req.shuffleArray(data);
+                }
+                result = data;
+              }
+            }
+            break;
+
+          case 'update':
+            // 处理更新操作
+            const id = req.params[primaryKey];
+            const updateData = req.body;
+            await ToolDb.update(table, updateData, { [primaryKey]: id });
+            result = { message: successMessage };
+            break;
+
+          case 'delete':
+            // 处理删除操作
+            const deleteId = req.params[primaryKey];
+            await ToolDb.delete(table, { [primaryKey]: deleteId });
+            result = { message: successMessage };
+            break;
+
+
+
+
+
+
+          default:
+            throw new Error('不支持的操作类型');
+        }
+      }
+
+      // 统一响应格式
+      res.json({ code: 200, data: result, message: successMessage });
+    } catch (error) {
+      // 统一错误处理
+      res.status(500).json({ code: 500, message: errorMessage, error: error.message });
+    }
+  };
+
+  defineRoute({
+    url,
+    method,
+    middlewares: finalMiddlewares,
+    handler: defaultHandler // 传递封装后的 handler
+  });
+
+}
+
+
+
+
+
+// 导出 app 实例（用于启动服务）
+export default app;

package/src/StreamlineCodeIndex.js

@@ -0,0 +1,5 @@
+export * from './Databaseope/DataIndex.js';
+export * from './Middleware/MiddleWareIndex.js'
+export * from './Tool/ToolIndex.js'
+export * from './Request/RequestIndex.js';
+export * from './Other/OtherIndex.js';

package/src/Tool/ToolIndex.js

@@ -0,0 +1 @@
+export * from './server.js';

package/src/Tool/server.js

@@ -0,0 +1,43 @@
+import express from 'express';
+import cors from 'cors';
+import app from "../Request/StreamlineCode.js";
+
+/**
+ * 启动服务器
+ * @param {Object} options - 配置选项
+ * @param {number} options.port - 服务器端口，默认3001
+ * @param {string[]} options.allowedOrigins - 允许的域名列表
+ */
+export function startServer(options = {}) {
+  const { 
+    port = 3001, 
+    allowedOrigins = [
+      'http://127.0.0.1:5501',
+    ] 
+  } = options;
+
+  // 配置CORS
+  app.use(cors({
+    // 核心：白名单判断，只放行指定的域名
+    origin: (origin, callback) => {
+      // 允许白名单内的地址，或本地调试（origin为null的情况）
+      if (!origin || allowedOrigins.includes(origin)) {
+        callback(null, origin || '*'); // 放行
+      } else {
+        callback(null, false);
+      }
+    },
+    credentials: true, // 保留Cookie支持
+    methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
+    allowedHeaders: ['Content-Type', 'Authorization']
+  }));
+
+  // 配置中间件
+  app.use(express.json());
+  app.use(express.static('public'));
+
+  // 启动服务器
+  app.listen(port, () => {
+    console.log(`后端服务运行在 http://localhost:${port}`);
+  });
+}

package/types/index.d.ts

@@ -0,0 +1,154 @@
+/**
+ * express-lowcode-by-ikun2274 - 低代码 Express 路由构建器
+ * 提供数据库操作、分页、身份验证等功能
+ */
+declare module "express-lowcode-by-ikun2274" {
+  /**
+   * 数据库配置接口
+   */
+  export interface DbConfig {
+    /** 数据库主机地址 */
+    host: string;
+    /** 数据库用户名 */
+    user: string;
+    /** 数据库密码 */
+    password: string;
+    /** 数据库名称 */
+    database: string;
+  }
+
+  /**
+   * 服务器配置接口
+   */
+  export interface ServerConfig {
+    /** 服务器端口 */
+    port: number;
+    /** 允许的跨域域名列表 */
+    allowedOrigins: string[];
+  }
+
+  /**
+   * 数据库操作配置接口
+   */
+  export interface PlusHandlerDb {
+    /** 数据库表名 */
+    table: string;
+    /** 操作类型 */
+    operation: "read" | "create" | "update" | "delete";
+    /** 主键字段名，默认为 'id' */
+    primaryKey?: string;
+    /** 查询字段，默认为 '*' */
+    fields?: string;
+    /** 分类字段名，默认为 'category_id' */
+    categoryField?: string;
+    /** 其他配置 */
+    [key: string]: any;
+  }
+
+  /**
+   * 模式配置接口
+   */
+  export interface PlusHandlerMode {
+    /** 是否支持分页，默认为 false */
+    pagination?: boolean;
+    /** 是否需要身份验证，默认为 false */
+    requireAuth?: boolean;
+    /** 验证模式，可选 'login' 或 'register' */
+    validationMode?: string;
+    /** 是否打乱数据，默认为 false */
+    shuffle?: boolean;
+    /** 是否自动生成 ID，默认为 false */
+    autoGenerateId?: boolean;
+    /** 每页大小，默认为 10 */
+    pageSize?: number;
+    /** 其他配置 */
+    [key: string]: any;
+  }
+
+  /**
+   * 其他配置接口
+   */
+  export interface PlusHandlerOther {
+    /** 成功消息，默认为 '操作成功' */
+    successMessage?: string;
+    /** 错误消息，默认为 '操作失败' */
+    errorMessage?: string;
+    /** 自定义逻辑函数 */
+    customLogic?: (
+      req: any,
+      res: any,
+      ToolDb: any,
+      successMessage: string,
+      errorMessage: string,
+    ) => Promise<any>;
+    /** 其他配置 */
+    [key: string]: any;
+  }
+
+  /**
+   * 内置处理器配置接口
+   */
+  export interface PlusHandler {
+    /** 数据库操作配置 */
+    db: PlusHandlerDb;
+    /** 模式配置 */
+    Mode: PlusHandlerMode;
+    /** 其他配置 */
+    other?: PlusHandlerOther;
+  }
+
+  /**
+   * 路由配置接口
+   */
+  export interface RouteConfig {
+    /** 路由路径 */
+    url: string;
+    /** HTTP 方法 */
+    method: "get" | "post" | "put" | "delete";
+    /** 中间件数组（可选）//看你需求  因为我尽可能集成中间件了 */
+    middlewares?: Array<(req: any, res: any, next: () => void) => void>;
+    /** 内置处理器配置 */
+    PlusHandler: PlusHandler;
+    /** 其他配置 */
+    [key: string]: any;
+  }
+
+  /**
+   * 配置数据库连接
+   * @param config 数据库配置
+   *
+   */
+  export function setDbConfig(config: DbConfig): void;
+
+  /**
+   * 启动服务器
+   * @param config 服务器配置
+   */
+  export function startServer(config: ServerConfig): void;
+
+  /**
+   * 定义增强路由
+   * @param config 路由配置
+   * @param {Object} options - 路由配置选项
+   * @param {string} options.url    - 路由路径（必填）
+   * @param {string} options.method - HTTP 方法（GET/POST/PUT/DELETE，必填）
+   * 
+   * @param {Array<Function>} [options.middlewares=[]] - 中间件数组（可选）//看你需求  因为我尽可能集成中间件了
+   * @param {Object} options.PlusHandler - 额外处理选项（必填）
+   * @param {Object} options.PlusHandler.db - 数据库操作（必填）
+   * @param {string} options.PlusHandler.db.table - 数据库表名（必填）
+   * @param {string} options.PlusHandler.db.operation - 数据表操作（必填）select/insert/update/update/delete
+   * @param {string} [options.PlusHandler.db.primaryKey='id'] - 主键字段（可选）
+   * @param {string} [options.PlusHandler.db.fields='*'] - 查询字段（可选）
+   * @param {string} [options.PlusHandler.db.categoryField='category_id'] - 分类字段（可选）
+   * @param {Object} options.PlusHandler.Mode - 模式选项（必填）
+   * @param {boolean} [options.PlusHandler.Mode.pagination=false] - 是否支持分页（可选）
+   * @param {boolean} [options.PlusHandler.Mode.requireAuth=false] - 是否需要身份验证（可选）
+   * @param {boolean} [options.PlusHandler.Mode.shuffle=false] - 是否打乱数据（可选）
+   * @param {number} [options.PlusHandler.Mode.pageSize=10] - 每页大小（可选）
+   * @param {Object} options.PlusHandler.other - 其他选项（必填）
+   * @param {string} [options.PlusHandler.other.successMessage='操作成功'] - 成功消息（可选）
+   * @param {string} [options.PlusHandler.other.errorMessage='操作失败'] - 错误消息（可选）
+   */
+  export function DefineRoutePlus_A(config: RouteConfig): void;
+}