create-pixle-koa-template 1.0.0

package/template/middleware/notFound.js

@@ -0,0 +1,84 @@
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * 404 405中间件
+ * 处理404 405错误，返回自定义的JSON响应或HTML页面
+ */
+
+const notFoundMiddleware = async (ctx, next) => {
+
+    // 先执行所有其他中间件
+    await next();
+
+    // 如果已经有响应体，直接返回
+    if (ctx.body) {
+        return;
+    }
+
+    // 检查是否为405错误：路径存在但请求方法不允许
+    let isMethodNotAllowed = false;
+    let allowedMethods = [];
+    let pathExists = false;
+
+    if (ctx.app.context.registeredRoutes) {
+        const requestedPath = ctx.path;
+        const requestedMethod = ctx.method;
+
+        // 遍历所有注册的路由
+        for (const route of ctx.app.context.registeredRoutes) {
+            // 检查路径是否匹配
+            if (route.regexp && route.regexp.test(requestedPath)) {
+                pathExists = true;
+
+                // 如果路径匹配但方法不允许，收集允许的方法
+                if (!route.methods.includes(requestedMethod) && !route.methods.includes('HEAD')) {
+                    // 收集允许的方法（过滤掉HEAD方法，因为它通常是自动支持的）
+                    allowedMethods = [...new Set([...allowedMethods, ...route.methods.filter(m => m !== 'HEAD')])];
+                } else {
+                    // 如果请求方法是允许的，则不是405错误
+                    isMethodNotAllowed = false;
+                    break;
+                }
+            }
+        }
+
+        // 只有当路径存在且允许的方法不为空时，才是405错误
+        isMethodNotAllowed = pathExists && allowedMethods.length > 0;
+    }
+
+
+    // 处理405错误
+    if (isMethodNotAllowed) {
+        ctx.status = 405;
+        ctx.set('Allow', allowedMethods.join(', '));
+        ctx.type = 'application/json';
+        ctx.body = {
+            code: 405,
+            message: '请求方法不允许'
+        };
+    }
+    // 处理404错误
+    else {
+        // 无论当前状态码是什么，对于不存在的路径都设置为404
+        ctx.status = 404;
+
+        // 检查是否为静态资源请求
+        const isStaticResource = ctx.path.startsWith('/static/') ||
+            /\.(jpg|jpeg|png|gif|svg|css|js|html|ico|woff|woff2|ttf|eot)$/i.test(ctx.path);
+
+        if (isStaticResource) {
+            ctx.type = 'text/html';
+            ctx.body = fs.readFileSync(path.join(__dirname, '../public/404.html'), 'utf8');
+        } else {
+            ctx.type = 'application/json';
+            ctx.body = {
+                code: 404,
+                message: 'request not find'
+            };
+        }
+    }
+
+};
+
+module.exports = notFoundMiddleware;

package/template/middleware/upload.js

@@ -0,0 +1,165 @@
+const multer = require("@koa/multer");
+const path = require("path");
+const fs = require("fs");
+const dayjs = require("dayjs");
+const {upload:uploadConfig}=require('../config/index')
+// 上传配置
+const {uploadDir,maxSize,maxCount} = uploadConfig
+
+
+// 递归创建存储目录
+const mkdir = (dirPath) => {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+};
+
+/**
+ * 上传中间件主函数
+ *入参可选配置(对象)：
+ * @param {*} uploadPath  ：上传文件路径(可选)
+ * @param {*} limits  ：上传文件大小、个数限制可选配置，默认20MB、一次最多传9个文件 （可选）
+ *   limits：{
+      fileSize: 20 * 1024 * 1024, // 单个文件最大20MB
+      files: 9, //一次最多9个文件
+    }
+ * @param {*} allowedMimes ：允许文件类型，默认全部允许 （可选）,数组例如：["image/jpeg", "image/png", "image/gif", "image/webp"]
+ * @param {*} fileFilter ：自定义过滤函数 （可选）
+ * @returns
+ */
+const uploadMiddleware = ({
+  uploadPath = null,
+  limits = {},
+  allowedMimes = null,
+  fileFilter = null,
+} = {}) => {
+  // 配置存储引擎
+  const storage = multer.diskStorage({
+    destination: (req, file, cb) => {
+      //  通过 MIME 类型检测是图片类型还是其他文件
+      const targetDir =
+        uploadPath || file.mimetype.startsWith("image/")
+          ? uploadDir.image
+          : uploadDir.file;
+      //上传目录
+      let realUploadDir = path.join(
+        targetDir,
+        `${dayjs().format("YYYY/MM/DD")}`
+      );
+      //创建日期目录
+      mkdir(realUploadDir);
+
+      cb(null, realUploadDir);
+    },
+    filename: (req, file, cb) => {
+      //文件名前缀
+      let prefix=file.mimetype.startsWith("image/") ? "image" : "file";
+      // 生成唯一文件名
+      const fileExt = path.extname(file.originalname);
+      //格式：image或file+ 时间戳 + 随机数 + 文件扩展名
+      const fileName = `${prefix}_${Date.now()}_${Math.random()
+        .toString(36)
+        .substring(2)}${fileExt}`;
+      cb(null, fileName);
+    },
+  });
+
+  // 自定义文件过滤器
+  const _fileFilter = (req, file, cb) => {
+    // 如果传入了自定义过滤器，使用自定义的
+      if (fileFilter) {
+        return fileFilter(req, file, cb);
+      }
+      
+      // 如果指定了允许的 MIME 类型
+      if (Array.isArray(allowedMimes) && allowedMimes.length > 0) {
+        if (allowedMimes.includes(file.mimetype)) {
+          cb(null, true);
+        } else {
+          // 生成友好的错误信息
+          const allowedTypes = allowedMimes.map(item => {
+            const parts = item.split('/');
+            return parts.length > 1 ? parts[1] : parts[0];
+          });
+          
+          cb(
+            new Error(`仅支持 ${allowedTypes.join('、')} 格式的文件`),
+            false
+          );
+        }
+      } else {
+        // 没有限制，允许所有文件
+        cb(null, true);
+      }
+  };
+
+  // 创建 multer 实例
+  const multerUpload = multer({
+    storage,
+    limits: {
+      fileSize: maxSize, // 大小 限制
+      files: maxCount, //最多9个文件
+      ...limits,
+    },
+    fileFilter: _fileFilter,
+  });
+
+  // 错误处理函数
+  const handleMulterError = (err, ctx) => {
+    const multerFileErrors = [
+      { key: "LIMIT_FILE_SIZE", message: "文件大小超限" },
+      { key: "LIMIT_FILE_COUNT", message: "文件数量超限" },
+      { key: "LIMIT_UNEXPECTED_FILE", message: "意外的文件字段" },
+      { key: "LIMIT_FIELD_KEY", message: "字段名过长" },
+      { key: "LIMIT_FIELD_VALUE", message: "字段值过长" },
+      { key: "LIMIT_FIELD_COUNT", message: "字段数量超限" },
+      { key: "LIMIT_PART_COUNT", message: "表单字段数量超限" },
+    ];
+
+    const target =
+      err.code && multerFileErrors.find((item) => item.key === err.code);
+
+    ctx.status = 400;
+    ctx.body = {
+      code: 400,
+      message: target?.message ?? err.message ?? "上传失败",
+    };
+  };
+
+  // 适配函数 - 使用 try-catch
+  const handleUpload = (type, fieldName, fields = []) => {
+    let uploadMiddleware;
+
+    switch (type) {
+      case "single":
+        uploadMiddleware = multerUpload.single(fieldName);
+        break;
+      case "array":
+        uploadMiddleware = multerUpload.array(fieldName, fields[0]?.maxCount);
+        break;
+      case "fields":
+        uploadMiddleware = multerUpload.fields(fields);
+        break;
+      default:
+        throw new Error("Unknown upload type");
+    }
+
+    return async (ctx, next) => {
+      try {
+        await uploadMiddleware(ctx, next);
+      } catch (err) {
+        handleMulterError(err, ctx);
+      }
+    };
+  };
+
+  return {
+    single: (fieldName = "file") => handleUpload("single", fieldName),//单文件上传
+    array: (fieldName = "files") => handleUpload("array", fieldName),//多文件上传 - 相同字段
+    fields: (fields) => handleUpload("fields", null, fields),//多文件上传 -不同字段
+  };
+};
+
+module.exports = uploadMiddleware;
+
+

package/template/models/Auth.js

@@ -0,0 +1,11 @@
+const BaseDAO = require("./BaseDAO.js");
+
+class Auth extends BaseDAO {
+  constructor() {
+    //表名users
+    super("users");
+  }
+
+}
+
+module.exports = new Auth();

package/template/models/BaseDAO.js

@@ -0,0 +1,449 @@
+const  pool = require("../config/db");
+
+class BaseDAO {
+  constructor(tableName) {
+    this.tableName = tableName;
+    this.pool = pool;
+  }
+
+  /**
+   * 类型转换工具方法
+   * @param {*} value ：待转换的值
+   * @param {*} fieldType ：字段类型
+   * @returns 转换后的值
+   */
+  convertValue(value, fieldType = "string") {
+    if (
+      value === undefined ||
+      value === null ||
+      value === "" ||
+      Array.isArray(value)
+    ) {
+      return value;
+    }
+
+    switch (fieldType) {
+      case "number":
+      case "int":
+      case "integer":
+        return parseInt(value, 10);
+
+      case "float":
+      case "decimal":
+        return parseFloat(value);
+
+      case "boolean":
+      case "bool":
+        if (value === "true" || value === "1" || value === 1) return true;
+        if (value === "false" || value === "0" || value === 0) return false;
+        return Boolean(value);
+
+      case "date":
+        return new Date(value);
+
+      case "string":
+      default:
+        return String(value);
+    }
+  }
+
+  /**
+   * 自动类型转换查询参数
+   * @param {*} params ：待转换的参数
+   * @param {*} fieldTypes ：字段类型
+   * @returns 转换后的参数
+   */
+  convertQueryParams(params, fieldTypes = {}) {
+    const converted = {};
+
+    for (const [key, value] of Object.entries(params)) {
+      const fieldType = fieldTypes[key] || "string";
+      converted[key] = this.convertValue(value, fieldType);
+    }
+
+    return converted;
+  }
+
+  /**
+   * 执行 SQL查询 ,execute方式
+   * @param {*} sql ：SQL语句
+   * @param {*} params ：SQL参数
+   * @returns 执行结果，查询语句返回数组，其他操作返回对象
+   */
+  async execute(sql, params) {
+    try {
+      const [result] = await this.pool.execute(sql, params);
+      return result;
+    } catch (error) {
+      console.error("Database execute error:", error);
+      throw error;
+    }
+  }
+
+  /**
+   * 执行 SQL查询 ，query方式
+   * @param {*} sql ：SQL语句
+   * @param {*} params ：SQL参数
+   * @returns 执行结果，查询语句返回数组，其他操作返回对象
+   */
+  async query(sql, params = []) {
+    try {
+      const [result] = await this.pool.query(sql, params);
+      return result;
+    } catch (error) {
+      console.error("Database query error:", error);
+      throw error;
+    }
+  }
+
+  /**
+   * 构建 WHERE 条件子句
+   * @param {*} conditions ：查询条件
+   * @param {*} fieldTypes ：字段类型
+   * @returns 构建后的WHERE条件子句和参数
+   */
+  buildWhereClause(conditions = {}, fieldTypes = {}) {
+    const whereConditions = [];
+    const params = [];
+
+    // 先进行类型转换
+    const convertedConditions = this.convertQueryParams(conditions, fieldTypes);
+
+    for (const [key, value] of Object.entries(convertedConditions)) {
+      // 跳过空值
+      if (value === undefined || value === null || value === "") {
+        continue;
+      }
+
+      // 处理模糊搜索条件（使用 LIKE）
+      if (key.startsWith("$like_")) {
+        const field = key.replace("$like_", "");
+        whereConditions.push(`${field} LIKE ?`);
+        params.push(`%${value}%`);
+      }
+      // 处理时间范围搜索（开始时间）
+      else if (key.startsWith("$gte_")) {
+        const field = key.replace("$gte_", "");
+        whereConditions.push(`${field} >= ?`);
+        params.push(value);
+      }
+      // 处理时间范围搜索（结束时间）
+      else if (key.startsWith("$lte_")) {
+        const field = key.replace("$lte_", "");
+        whereConditions.push(`${field} <= ?`);
+        params.push(value);
+      }
+      // 处理时间范围搜索（区间）
+      else if (key.startsWith("$between_")) {
+        const field = key.replace("$between_", "");
+        if (Array.isArray(value) && value.length === 2) {
+          whereConditions.push(`${field} BETWEEN ? AND ?`);
+          params.push(value[0], value[1]);
+        }
+      }
+      // 处理 IN 查询
+      else if (key.startsWith("$in_")) {
+        const field = key.replace("$in_", "");
+        if (Array.isArray(value) && value.length > 0) {
+          const placeholders = value.map(() => "?").join(", ");
+          whereConditions.push(`${field} IN (${placeholders})`);
+          params.push(...value);
+        }
+      }
+      // 普通等值查询
+      else {
+        whereConditions.push(`${key} = ?`);
+        params.push(value);
+      }
+    }
+
+    return {
+      whereClause:
+        whereConditions.length > 0
+          ? `WHERE ${whereConditions.join(" AND ")}`
+          : "",
+      params,
+    };
+  }
+
+  /**
+   * 查询所有记录
+   * @param {*} conditions ：查询条件
+   * @param {*} options ：查询选项
+   * @param {*} fieldTypes ：字段类型
+   * @returns 查询结果
+   */
+  async findAll(conditions = {}, options = {}, fieldTypes = {}) {
+    let sql = `SELECT * FROM ${this.tableName}`;
+    // 构建 WHERE 条件
+    const { whereClause, params } = this.buildWhereClause(
+      conditions,
+      fieldTypes
+    );
+    sql += ` ${whereClause}`;
+
+    // 添加排序
+    if (options.orderBy) {
+      sql += ` ORDER BY ${options.orderBy}`;
+      if (options.orderDirection) {
+        sql += ` ${options.orderDirection}`;
+      }
+    }
+
+    // 添加分页
+    if (typeof options.limit === "number" && options.limit > 0) {
+      sql += " LIMIT ?";
+      params.push(BigInt(options.limit));
+
+      if (typeof options.offset === "number" && options.offset >= 0) {
+        sql += " OFFSET ?";
+        params.push(BigInt(options.offset));
+      }
+    }
+
+    return await this.execute(sql, params);
+  }
+
+  /**
+   * 根据 ID 查询单条记录
+   * @param {*} id ：记录ID
+   * @returns 查询结果
+   */
+  async findById(id) {
+    const sql = `SELECT * FROM ${this.tableName} WHERE id = ?`;
+    const rows = await this.execute(sql, [id]);
+    return rows?.length > 0 ? rows[0] : null;
+  }
+
+  /**
+   * 查询单条记录
+   * @param {*} conditions ：查询条件
+   * @returns 查询结果
+   */
+  async findOne(conditions = {}) {
+    const rows = await this.findAll(conditions, { limit: 1 });
+    return rows?.length > 0 ? rows[0] : null;
+  }
+
+  /**
+   *  检查某字段值是否存在数据库
+   * @param {*} key : 字段名
+   * @param {*} value : 字段值
+   * @returns : true/false
+   */
+  async isFieldValueExists(key, value) {
+    let conditions = {};
+    conditions[key] = value;
+    const row = await this.findOne(conditions);
+    return !!row;
+  }
+
+  /**
+   * 插入记录
+   */
+  async create(data) {
+    const keys = Object.keys(data);
+    const values = Object.values(data);
+    const placeholders = keys.map(() => "?").join(", ");
+
+    const sql = `INSERT INTO ${this.tableName} (${keys.join(
+      ", "
+    )}) VALUES (${placeholders})`;
+    const result = await this.execute(sql, values);
+
+    return {
+      id: result.insertId,
+      ...data,
+    };
+  }
+
+  /**
+   * 批量插入
+   */
+  async createMany(items) {
+    if (items.length === 0) return [];
+
+    const keys = Object.keys(items[0]);
+    const values = items.map((item) => Object.values(item));
+    const placeholders = items
+      .map(() => `(${keys.map(() => "?").join(", ")})`)
+      .join(", ");
+
+    const sql = `INSERT INTO ${this.tableName} (${keys.join(
+      ", "
+    )}) VALUES ${placeholders}`;
+    const result = await this.execute(sql, values.flat());
+
+    return result;
+  }
+
+  /**
+   * 更新记录
+   * @param {*} id ：记录ID
+   * @param {*} data ：更新数据
+   * @returns ：true/false
+   */
+  async update(id, data) {
+    const keys = Object.keys(data);
+    const values = Object.values(data);
+
+    const setClause = keys.map((key) => `${key} = ?`).join(", ");
+    const sql = `UPDATE ${this.tableName} SET ${setClause} WHERE id = ?`;
+
+    const result = await this.execute(sql, [...values, id]);
+    return result.affectedRows > 0;
+  }
+
+  /**
+   * 条件更新
+   * @param {*} conditions ：条件
+   * @param {*} data ：更新数据
+   * @returns ：true/false
+   */
+  async updateWhere(conditions, data) {
+    const dataKeys = Object.keys(data);
+    const conditionKeys = Object.keys(conditions);
+
+    const setClause = dataKeys.map((key) => `${key} = ?`).join(", ");
+
+    // 构建 WHERE 条件
+    const { whereClause, params: conditionParams } =
+      this.buildWhereClause(conditions);
+
+    const values = [...Object.values(data), ...conditionParams];
+    const sql = `UPDATE ${this.tableName} SET ${setClause} ${whereClause}`;
+
+    const result = await this.execute(sql, values);
+    return result.affectedRows > 0;
+  }
+
+  /**
+   * 删除记录
+   * @param {*} id ：记录ID
+   * @returns ：true/false
+   */
+  async delete(id) {
+    const sql = `DELETE FROM ${this.tableName} WHERE id = ?`;
+    const result = await this.execute(sql, [id]);
+    return result.affectedRows > 0;
+  }
+
+  /**
+   * 条件删除
+   * @param {*} conditions ：查询条件
+   * @returns ：删除的记录数
+   */
+  async deleteWhere(conditions) {
+    const { whereClause, params } = this.buildWhereClause(conditions);
+    const sql = `DELETE FROM ${this.tableName} ${whereClause}`;
+    const result = await this.execute(sql, params);
+    return result.affectedRows > 0;
+  }
+
+  /**
+   * 计数
+   * @param {*} conditions ：查询条件
+   * @param {*} fieldTypes ：字段类型
+   * @returns ：记录数
+   */
+  async count(conditions = {}, fieldTypes = {}) {
+    let sql = `SELECT COUNT(*) as total FROM ${this.tableName}`;
+
+    // 构建 WHERE 条件
+    const { whereClause, params } = this.buildWhereClause(
+      conditions,
+      fieldTypes
+    );
+    sql += ` ${whereClause}`;
+
+    const rows = await this.execute(sql, params);
+    return rows[0].total;
+  }
+
+  /**
+   * 分页查询
+   * @param {*} page ：页码
+   * @param {*} pageSize ：每页数量
+   * @param {*} conditions ：查询条件
+   * @param {*} options ：查询选项
+   * @param {*} fieldTypes ：字段类型
+   * @returns ：分页结果
+   */
+  async paginate(
+    page = 1,
+    pageSize = 10,
+    conditions = {},
+    options = {},
+    fieldTypes = {}
+  ) {
+    page = parseInt(page);
+    pageSize = parseInt(pageSize);
+    if (isNaN(page) || page < 1) page = 1;
+    if (isNaN(pageSize) || pageSize < 1) size = 10;
+
+    const offset = (page - 1) * pageSize;
+    const data = await this.findAll(
+      conditions,
+      {
+        ...options,
+        limit: pageSize,
+        offset: offset,
+      },
+      fieldTypes
+    );
+
+    const total = await this.count(conditions, fieldTypes);
+    const totalPages = Math.ceil(total / pageSize);
+
+    return {
+      list: data,
+      pagination: {
+        page: parseInt(page),
+        pageSize: parseInt(pageSize),
+        total,
+        totalPages,
+        hasNext: page < totalPages,
+        hasPrev: page > 1,
+      },
+    };
+  }
+  /**
+   * 高级搜索方法（新增）
+   */
+  async advancedSearch(searchConfig = {}) {
+    const {
+      keyword = "",
+      keywordFields = [], // 要搜索的字段数组
+      conditions = {},
+      dateRangeField = "",
+      startDate = "",
+      endDate = "",
+      options = {},
+    } = searchConfig;
+
+    let finalConditions = { ...conditions };
+
+    // 处理关键词搜索
+    if (keyword && keywordFields.length > 0) {
+      // 如果有多个字段需要关键词搜索，使用 OR 条件
+      const keywordConditions = keywordFields.map((field) => ({
+        [`$like_${field}`]: keyword,
+      }));
+
+      // 这里简化处理，实际可以更复杂
+      finalConditions = {
+        ...finalConditions,
+        ...keywordConditions[0], //
+      };
+    }
+
+    // 处理时间范围
+    if (dateRangeField && startDate && endDate) {
+      finalConditions[`$between_${dateRangeField}`] = [startDate, endDate];
+    }
+
+    return await this.findAll(finalConditions, options);
+  }
+}
+
+module.exports = BaseDAO;