chanjs 1.1.5 → 1.1.7

package/core/helper.js

@@ -71,3 +71,30 @@ export const loadWebToEnd = function(module=[]){
   }
   return module;
 }
+
+
+// import { z } from "zod";
+
+export const zodValidator = (schemas) => (req, res, next) => {
+  // 分别验证 headers/params/query/body
+  const sections = {
+    headers: schemas.headers,
+    params: schemas.params,
+    query: schemas.query,
+    body: schemas.body
+  };
+
+  for (const [key, schema] of Object.entries(sections)) {
+    if (!schema) continue;
+    
+    const result = schema.safeParse(req[key]);
+    if (!result.success) {
+      // 返回首个错误信息
+      const firstError = result.error.errors[0];
+      return res.status(400).json({ error: firstError.message });
+    }
+    // 将验证后的数据挂载到 req 对象
+    req[key] = result.data;
+  }
+  next();
+};

package/core/lib/cache.js

@@ -1,4 +1,4 @@
-class Cache {
+export default class Cache {
     constructor(maxSize = 1000) {
       this.cache = new Map(); // 使用 Map 存储缓存数据
       this.maxSize = maxSize; // 缓存最大容量
@@ -104,7 +104,6 @@ class Cache {
     }
 }
 
-export default new Cache();
   
 //   // 示例用法
 //   const cache = new SimpleCache(100); // 设置缓存最大容量为 100

package/core/lib/service.js

@@ -3,7 +3,7 @@ class BaseService {
    * @description 构造函数
    * @param {*} knex - knex实例
    */
-  constructor(DB=Chan.knex) {
+  constructor(DB = Chan.knex) {
     this.knex = DB;
     this.DB = DB;
     this.model = ''; // 默认为空字符串
@@ -14,187 +14,187 @@ class BaseService {
    * @param {Object} query - 包含查询参数的对象
    * @returns {Promise} 返回所有记录
    */
-  all(query={}) {
-    if(Object.keys(query).length === 0) {
+  all(query = {}) {
+    if (Object.keys(query).length === 0) {
       return this.DB(this.model).select();
     }
     return this.DB(this.model).where(query).select();
   }
 
- /**
- * @description 根据指定条件查询记录
- * @param {Object} options - 包含查询参数的对象
- * @param {string} options.id - 查询字段名，默认为 'id'
- * @param {*} options.value - 查询字段值，默认为 0
- * @param {Array} options.field - 需要返回的字段数组，默认为空（即选择所有字段）
- * @param {number} options.len - 期望获取的记录数量，默认为 1（如果为 1 则使用 `.first()`，否则使用 `.limit(len)`）
- * @returns {Promise} 返回匹配条件的记录或记录列表
- */
-async findById({ query, field = [], len = 1 }) {
-  let dataQuery = this.DB(this.model).where(query);
-
-  // 字段筛选
-  if (field.length > 0) {
-    dataQuery = dataQuery.select(field);
-  }
+  /**
+  * @description 根据指定条件查询记录
+  * @param {Object} options - 包含查询参数的对象
+  * @param {string} options.id - 查询字段名，默认为 'id'
+  * @param {*} options.value - 查询字段值，默认为 0
+  * @param {Array} options.field - 需要返回的字段数组，默认为空（即选择所有字段）
+  * @param {number} options.len - 期望获取的记录数量，默认为 1（如果为 1 则使用 `.first()`，否则使用 `.limit(len)`）
+  * @returns {Promise} 返回匹配条件的记录或记录列表
+  */
+  async findById({ query, field = [], len = 1 }) {
+    let dataQuery = this.DB(this.model).where(query);
+
+    // 字段筛选
+    if (field.length > 0) {
+      dataQuery = dataQuery.select(field);
+    }
 
-  // 根据len决定是获取单条记录还是多条记录
-  if (len === 1) {
-    dataQuery = dataQuery.first();
-  } else if (len > 1) {
-    dataQuery = dataQuery.limit(len);
+    // 根据len决定是获取单条记录还是多条记录
+    if (len === 1) {
+      dataQuery = dataQuery.first();
+    } else if (len > 1) {
+      dataQuery = dataQuery.limit(len);
+    }
+    let res = await dataQuery;
+    //返回结果 undefined 则返回空数组或空对象
+    return res || (len === 1 ? {} : []);
   }
-  let res = await dataQuery;
-  //返回结果 undefined 则返回空数组或空对象
-  return res  || (len === 1 ? {} : []);
-}
 
 
-/**
- * @description 创建新记录
- * @param {Object} data - 包含要插入的数据对象
- * @returns {Promise<boolean>} 返回操作是否成功
- */
-async insert(data = {}) {
-  if (Object.keys(data).length === 0) {
-    return false;
+  /**
+   * @description 创建新记录
+   * @param {Object} data - 包含要插入的数据对象
+   * @returns {Promise<boolean>} 返回操作是否成功
+   */
+  async insert(data = {}) {
+    if (Object.keys(data).length === 0) {
+      return false;
+    }
+    const result = await this.DB(this.model).insert(data);
+    return result?.length > 0 || !!result;
   }
-  const result = await this.DB(this.model).insert(data);
-  return result?.length > 0 || !!result;
-}
 
   /**
  * @description 插入多条记录
  * @param {Array} records - 包含要插入的数据对象数组 [{<key>:<value>}, {<key>:<value>}, ...]
  * @returns {Promise<Array|Number>} 返回插入后的记录或受影响行数，具体取决于数据库驱动
  */
-  async insertMany(records=[]) {
+  async insertMany(records = []) {
     // 如果没有提供数据或者数据为空，则直接返回 false 或者抛出异常
     if (records.length === 0) {
       console.log('插入数据不能为空')
       return false;
     }
-  
+
     // 执行插入操作并获取结果
     const result = await this.DB(this.model).insert(records);
-  
+
     // 返回插入的结果
     return result;
   }
-  
- /**
- * @description 根据指定条件删除记录
- * @param {Object} query - 包含查询条件的对象
- * @returns {Promise<boolean>} 返回操作是否成功（即是否有任何记录被删除）
- */
- async delete(query = {}) {
-  if (Object.keys(query).length === 0) {
-    return false;
+
+  /**
+  * @description 根据指定条件删除记录
+  * @param {Object} query - 包含查询条件的对象
+  * @returns {Promise<boolean>} 返回操作是否成功（即是否有任何记录被删除）
+  */
+  async delete(query = {}) {
+    if (Object.keys(query).length === 0) {
+      return false;
+    }
+    const affectedRows = await this.DB(this.model).where(query).del();
+    return affectedRows > 0;
   }
-  const affectedRows = await this.DB(this.model).where(query).del();
-  return affectedRows > 0;
-}
-/**
- * @description 根据指定条件更新记录
- * @param {Object} query - 查询条件
- * @param {number} params - 保存内容
- * @returns {Promise<boolean>} 返回操作是否成功
- */
-async  update({query, params} = {}) {
+  /**
+   * @description 根据指定条件更新记录
+   * @param {Object} query - 查询条件
+   * @param {number} params - 保存内容
+   * @returns {Promise<boolean>} 返回操作是否成功
+   */
+  async update({ query, params } = {}) {
     const result = await this.DB(this.model).where(query).update(params);
     return { affectedRows: result };
-}
+  }
 
 
-/**
- * @description 批量更新多条记录（基于事务保证原子性）
- * @param {Array<{query: Object, params: Object}>} updates - 更新操作数组，每个元素包含查询条件和更新内容
- * @returns {Promise<{ affectedRows: number[] }>} 返回每个操作影响的行数数组
- */
-async updateMany(updates = []) {
-  // 参数合法性校验
-  if (!Array.isArray(updates)) {
+  /**
+   * @description 批量更新多条记录（基于事务保证原子性）
+   * @param {Array<{query: Object, params: Object}>} updates - 更新操作数组，每个元素包含查询条件和更新内容
+   * @returns {Promise<{ affectedRows: number[] }>} 返回每个操作影响的行数数组
+   */
+  async updateMany(updates = []) {
+    // 参数合法性校验
+    if (!Array.isArray(updates)) {
       throw new Error('参数必须为数组格式');
-  }
+    }
+
+    // 获取事务对象
+    const trx = await this.DB.transaction();
 
-  // 获取事务对象
-  const trx = await this.DB.transaction();
-  
-  try {
+    try {
       const affectedRows = [];
       // 循环处理每个更新操作
       for (const { query, params } of updates) {
-          // 执行单个更新操作，使用事务对象替换原有knex实例
-          const result = await trx(this.model)
-              .where(query)
-              .update(params);
-          affectedRows.push(result);
+        // 执行单个更新操作，使用事务对象替换原有knex实例
+        const result = await trx(this.model)
+          .where(query)
+          .update(params);
+        affectedRows.push(result);
       }
       // 提交事务
       await trx.commit();
       // 返回影响行数数组（与入参顺序一致）
       return { affectedRows };
-  } catch (err) {
+    } catch (err) {
       // 回滚事务
       await trx.rollback();
       // 错误向上抛出，由调用者处理
       throw err;
+    }
   }
-}
 
 
 
 
- /**
- * 查找所有符合条件的记录，并提供分页信息。
- * @param {Object} options - 包含查询参数的对象
- * @param {number} options.current - 当前页码，默认第一页
- * @param {number} options.pageSize - 每页大小，默认10条记录
- * @param {Object} options.query - 查询条件
- * @param {Array} options.field - 需要返回的字段
- * @returns {Promise<Object>} 返回包含数据列表、总记录数、当前页、每页大小的对象
- */
- async query({current = 1, pageSize = 10, query = {},field = []}) {
-  const offset = (current - 1) * pageSize;
-  let countQuery = this.DB(this.model).count("* as total");
-  let dataQuery = this.DB(this.model);
-  // 应用查询条件
-  if(Object.keys(query).length > 0){
-    Object.entries(query).forEach(([key, value]) => {
-      dataQuery = dataQuery.where(key, value);
-      countQuery = countQuery.where(key,value);
-    })
-  }
+  /**
+  * 查找所有符合条件的记录，并提供分页信息。
+  * @param {Object} options - 包含查询参数的对象
+  * @param {number} options.current - 当前页码，默认第一页
+  * @param {number} options.pageSize - 每页大小，默认10条记录
+  * @param {Object} options.query - 查询条件
+  * @param {Array} options.field - 需要返回的字段
+  * @returns {Promise<Object>} 返回包含数据列表、总记录数、当前页、每页大小的对象
+  */
+  async query({ current = 1, pageSize = 10, query = {}, field = [] }) {
+    const offset = (current - 1) * pageSize;
+    let countQuery = this.DB(this.model).count("* as total");
+    let dataQuery = this.DB(this.model);
+    // 应用查询条件
+    if (Object.keys(query).length > 0) {
+      Object.entries(query).forEach(([key, value]) => {
+        dataQuery = dataQuery.where(key, value);
+        countQuery = countQuery.where(key, value);
+      })
+    }
 
-  //字段筛选
-  if(field.length > 0){
-    dataQuery = dataQuery.select(field);
-  }
+    //字段筛选
+    if (field.length > 0) {
+      dataQuery = dataQuery.select(field);
+    }
 
-  //并行执行获取总记录数和分页数据的查询
-  const [totalResult, list] = await Promise.all([countQuery.first(), dataQuery.offset(offset).limit(pageSize)]);
-  // 提取总记录数
-  const total =  totalResult?.total || 0;
+    //并行执行获取总记录数和分页数据的查询
+    const [totalResult, list] = await Promise.all([countQuery.first(), dataQuery.offset(offset).limit(pageSize)]);
+    // 提取总记录数
+    const total = totalResult?.total || 0;
 
-  return { list, total, current, pageSize };
-}
+    return { list, total, current, pageSize };
+  }
 
 
- /**
- * @description 查询指定条件的记录数量
- * @param {Array} query - 数组形式的多个条件 [{<key>:<value>}, {<key>:<value>}, ...]
- * @returns {Promise<number>} 返回符合条件的记录数量
- */
-  async count(query=[]) {
-      let dataQuery = this.DB(this.model);
-      if(query.length >0){
-        query.forEach((condition) => {
-            dataQuery = dataQuery.where(condition);
-        });
-      }
-      const result = await dataQuery.count("* as total").first();
-      return result.total || 0;
+  /**
+  * @description 查询指定条件的记录数量
+  * @param {Array} query - 数组形式的多个条件 [{<key>:<value>}, {<key>:<value>}, ...]
+  * @returns {Promise<number>} 返回符合条件的记录数量
+  */
+  async count(query = []) {
+    let dataQuery = this.DB(this.model);
+    if (query.length > 0) {
+      query.forEach((condition) => {
+        dataQuery = dataQuery.where(condition);
+      });
+    }
+    const result = await dataQuery.count("* as total").first();
+    return result.total || 0;
   }
-  
+
 }
 export default BaseService;

package/core/lib/task.js

@@ -0,0 +1,140 @@
+const schedule = require('node-schedule');
+
+export default class Task {
+  constructor(config = {}) {
+    this.tasks = new Map();
+    this.config = {
+      taskPrefix: 'TASK_',
+      maxRetry: 3,
+      onError: (id, err) => console.error(`[${id}] Error: ${err.message}`),
+      ...config
+    };
+  }
+
+  /**
+   * 添加定时任务
+   * @param {string|Date|Object} rule - 调度规则（Cron/Date/RecurrenceRule）
+   * @param {Function} callback - 任务回调函数
+   * @param {boolean} [immediate=false] - 是否立即执行首次
+   * @returns {string} 任务ID
+   */
+  addTask(rule, callback, immediate = false) {
+    const taskId = `${this.config.taskPrefix}${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
+    
+    // 创建任务[2,7](@ref)
+    const job = schedule.scheduleJob(taskId, rule, async () => {
+      try {
+        await callback(taskId);
+        job.emit('success');
+      } catch (error) {
+        job.emit('error', error);
+      }
+    });
+
+    // 事件监听[5](@ref)
+    job
+      .on('scheduled', () => console.log(`[${taskId}] 任务已计划`))
+      .on('run', () => console.log(`[${taskId}] 任务执行中`))
+      .on('success', () => console.log(`[${taskId}] 执行成功`))
+      .on('error', (err) => this.config.onError(taskId, err))
+      .on('canceled', () => console.log(`[${taskId}] 已取消`));
+
+    this.tasks.set(taskId, job);
+
+    // 立即执行首次[3](@ref)
+    if (immediate) {
+      process.nextTick(() => callback(taskId));
+    }
+
+    return taskId;
+  }
+
+  /**
+   * 创建循环规则任务（简化版）
+   * @param {Object} options - 循环规则配置 { hour, minute, dayOfWeek 等 }
+   * @param {Function} callback - 任务回调
+   * @param {boolean} [immediate] - 是否立即执行
+   */
+  addRecurringTask(options, callback, immediate) {
+    const rule = new schedule.RecurrenceRule();
+    Object.assign(rule, options);
+    return this.addTask(rule, callback, immediate);
+  }
+
+  /**
+   * 取消任务
+   * @param {string} taskId - 任务ID
+   * @param {boolean} [graceful=true] - 是否等待当前执行完成
+   * @returns {boolean} 是否取消成功
+   */
+  cancelTask(taskId, graceful = true) {
+    const job = this.tasks.get(taskId);
+    if (!job) return false;
+
+    graceful ? job.cancel() : job.cancelNext();
+    this.tasks.delete(taskId);
+    return true;
+  }
+
+  /**
+   * 取消所有任务[4](@ref)
+   */
+  cancelAllTasks() {
+    this.tasks.forEach(job => job.cancel());
+    this.tasks.clear();
+    schedule.gracefulShutdown();
+  }
+
+  /**
+   * 获取任务状态
+   * @param {string} taskId - 任务ID
+   * @returns {'pending'|'running'|'canceled'} 任务状态
+   */
+  getTaskStatus(taskId) {
+    const job = this.tasks.get(taskId);
+    if (!job) return 'canceled';
+    return job.pendingInvocations.length > 0 ? 'pending' : 'running';
+  }
+
+  /**
+   * 获取所有任务ID
+   * @returns {string[]} 任务ID列表
+   */
+  getAllTaskIds() {
+    return Array.from(this.tasks.keys());
+  }
+}
+
+// ==================== 使用示例 ====================
+// const scheduler = new TaskScheduler({
+//   onError: (id, err) => console.error(`[ALERT] 任务 ${id} 失败: ${err.message}`)
+// });
+
+// // 示例1: Cron表达式任务（每分钟30秒时执行）[2](@ref)
+// const task1 = scheduler.addTask('30 * * * * *', (id) => {
+//   console.log(`[${id}] 执行时间: ${new Date().toISOString()}`);
+// });
+
+// // 示例2: 对象语法任务（每天9:30执行）[3](@ref)
+// const task2 = scheduler.addRecurringTask(
+//   { hour: 9, minute: 30 },
+//   (id) => console.log(`[${id}] 晨间任务执行`)
+// );
+
+// // 示例3: 每月1号执行（月初任务）[6](@ref)
+// const task3 = scheduler.addTask('0 0 1 * *', (id) => {
+//   console.log(`[${id}] 月初自动报表生成`);
+// });
+
+// // 示例4: 5秒后执行的一次性任务
+// const task4 = scheduler.addTask(
+//   new Date(Date.now() + 5000),
+//   (id) => console.log(`[${id}] 一次性任务完成`),
+//   true  // 立即先执行一次
+// );
+
+// // 取消任务示例
+// setTimeout(() => {
+//   scheduler.cancelTask(task1);
+//   console.log('当前活跃任务:', scheduler.getAllTaskIds());
+// }, 10000);

package/core/lib/view.js

@@ -1,6 +1,6 @@
 import path from "path";
-import dayjs from 'dayjs';
-import { createRequire } from 'module';
+import dayjs from "dayjs";
+import { createRequire } from "module";
 const require = createRequire(import.meta.url);
 
 const template = require("art-template");
@@ -24,8 +24,8 @@ template.defaults.imports.dateFormat = function (date, format) {
 
 export default (app, config) => {
   const { APP_PATH, views, env } = config;
- //合并插件中的view
-  const all = [...views, 'app/modules/web/view'];
+  //合并插件中的view
+  const all = [...views, "app/modules/web/view"];
 
   app.set("view options", {
     debug: env === "dev",

package/index.js

@@ -4,30 +4,26 @@ import fs from "fs";
 import cors from "cors";
 import { pathToFileURL } from 'url';  // 新增顶部导入
 import config from "./core/config.js";
-import {bindClass,createKnex,loadWebToEnd} from "./core/helper.js";
-
-
-
+import * as helper from "./core/helper.js";
 import Service from "./core/lib/service.js";
-import cache from './core/lib/cache.js';
+import Cache from './core/lib/cache.js';
+import Task from "./core/lib/task.js";
 import core from "./core/lib/index.js";
-
+const {bindClass, createKnex, loadWebToEnd} = helper;
 /**
  * @description 基于express封装的mvc框架，遵循约定优于配置原则
  */
 class Chan {
-  static helper = {};
+  static helper = helper;
   static modules = {};
   static plugins = {};
   static config = config;
-  static cache = cache;
-
- 
+  static Cache = Cache;
+  static Task = Task;
   constructor() {
     this.app = express();
     this.router = express.Router();
   }
-
   async init() {
     await this.loadConfig();
     await this.loadExtends();
@@ -35,12 +31,6 @@ class Chan {
     this.loadDB();
     this.loadCors();
   }
-
-  extend(name, fn) {
-    this.app.plus[name] = ()=>fn;
-  }
-
-
   async loadConfig() {
     const configPath = path.join(Chan.config.APP_PATH, "config/index.js");
     if (fs.existsSync(configPath)) {
@@ -72,11 +62,11 @@ class Chan {
 
   //数据库操作
   loadDB() {
-    if(Chan.config?.db?.length > 0){
-      Chan.config.db.map((item,index) => {
-        if(index ==0){
+    if (Chan.config?.db?.length > 0) {
+      Chan.config.db.map((item, index) => {
+        if (index == 0) {
           Chan.knex = createKnex(item);
-        }else{
+        } else {
           Chan[`knex${index}`] = createKnex(item);
         }
       })
@@ -84,6 +74,11 @@ class Chan {
     }
   }
 
+  //解决跨域
+  loadCors() {
+    Chan.config?.cors?.origin && this.app.use(cors(Chan.config.cors));
+  }
+
   //开始启动
   beforeStart(cb) {
     cb && cb();
@@ -97,14 +92,9 @@ class Chan {
     cb && cb();
   }
 
-  //解决跨域
-  loadCors() {
-    Chan.config?.cors?.origin && this.app.use(cors(Chan.config.cors));
-  }
-
   // 加载插件
   async loadPlugins() {
-   await this.loadModules("plugins");
+    await this.loadModules("plugins");
   }
 
   /**
@@ -115,7 +105,7 @@ class Chan {
     if (fs.existsSync(configPath)) {
       const dirs = loadWebToEnd(Chan.config[modules]);
       Chan[modules] = {};
-  
+
       // 先加载所有服务
       for (const item of dirs) {
         Chan[modules][item] = {
@@ -124,14 +114,13 @@ class Chan {
         };
         await this.loadServices(modules, item); // 确保每个模块的服务加载完成
       }
-  
+
       // 加载控制器和路由
       for (const item of dirs) {
         await this.loadModule(modules, item); // 确保每个模块的加载完成
       }
     }
   }
-  
 
   /**
    * @description 加载模块，包括 controller service router
@@ -146,13 +135,18 @@ class Chan {
     const dir = path.join(Chan.config.APP_PATH, modules, moduleName, type);
     if (fs.existsSync(dir)) {
       const files = fs.readdirSync(dir).filter(file => file.endsWith(".js"));
-      for (const file of files) { // 使用 for...of 确保异步操作顺序
-        const filePath = path.join(dir, file);
-        const fileUrl = pathToFileURL(filePath).href;
-        const module = await import(fileUrl);
-        const name = file.replace(".js", "");
-        Chan[modules][moduleName][type][name] = { ...bindClass(module.default) };
-      }
+      await Promise.all(files.map(async (file) => {
+        try {
+          const filePath = path.join(dir, file);
+          const fileUrl = pathToFileURL(filePath).href;
+          const module = await import(fileUrl);
+          const name = file.replace(".js", "");
+          Chan[modules][moduleName][type][name] = { ...bindClass(module.default) };
+        } catch (e) {
+          console.error(`加载${type}模块失败: ${file}`, e);
+          throw e;
+        }
+      }));
     }
   }
 
@@ -162,7 +156,7 @@ class Chan {
    * @param {*} moduleName 模块名称
    */
   async loadServices(modules, moduleName) {
-   await this.loadFiles(modules, moduleName, "service");
+    await this.loadFiles(modules, moduleName, "service");
   }
 
   /**
@@ -205,7 +199,7 @@ class Chan {
   run(cb) {
     const port = Chan.config.port || "81";
     this.app.listen(port, () => {
-      cb?cb(port):console.log(`Server is running on port ${port}`);
+      cb ? cb(port) : console.log(`Server is running on port ${port}`);
     });
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "chanjs",
-  "version": "1.1.5",
+  "version": "1.1.7",
   "description": "chanjs基于express5 纯js研发的轻量级mvc框架。",
   "main": "index.js",
   "module": "index.js",