chanjs 1.2.5 → 2.0.0

package/core/config.js

@@ -1,52 +0,0 @@
-import path from 'path';
-import { createRequire } from 'module';
-import { pathToFileURL } from 'url';
-
-const require = createRequire(import.meta.url);
-
-/**
- * @description 根目录（ESM 兼容写法）
- */
-const __dirname = path.dirname(new URL(import.meta.url).pathname);
-const ROOT_PATH = process.cwd();
-
-// 使用 require 读取 package.json（更简单可靠）
-const pkg = require(path.join(ROOT_PATH, 'package.json'));
-const { version = '1.0.0', author = '明空' } = pkg;
-/**
- * @description 程序目录
- */
-const APP_PATH = path.join(ROOT_PATH, 'app');
-
-const baseConfig = {
-  JSON_LIMIT: "100kb",
-  logger: {
-    level: 'dev',
-  },
-  version,
-  author,
-  env: 'dev',
-  template: 'default',
-  views: [],
-  static: [{
-    prefix: "/public/",
-    dir: ["app/public"],
-    maxAge: 0,
-  }],
-  database: {
-    client: "mysql2",
-    host: "localhost",
-    port: "3306",
-    user: "root",
-    password: "123456",
-    database: "chancms",
-    charset: "utf8mb4",
-  },
-};
-
-// 导出配置对象
-export default {
-  ROOT_PATH,
-  APP_PATH,
-  ...baseConfig
-};

package/core/helper.js

@@ -1,105 +0,0 @@
-import knex from 'knex';
-import merge from 'deepmerge';
-
-/**
- * @description 实例化一个类，并将该类的所有方法绑定到一个新的对象上。
- * @param {Function} className - 需要实例化的类。
- *@returns {Object} 包含绑定方法的对象。
- */
- export const bindClass = function(className) {
-  let obj = {};
-  const cls = new className();
-  Object.getOwnPropertyNames(cls.constructor.prototype).forEach(
-    (methodName) => {
-      if (
-        methodName !== "constructor" &&
-        typeof cls[methodName] === "function"
-      ) {
-        obj[methodName] = cls[methodName].bind(cls);
-      }
-    }
-  );
-  return obj;
-}
-
-
-export const createKnex = function(opt) {
-    let config = {
-        host:"localhost",
-        port:"3306",
-        client:"mysql2",
-        charset:"utf8mb4",
-        debug:false,
-        ...opt
-    };
-    return knex({
-      client: config.client,
-      connection: {
-        host:config.host,
-        port:config.port,
-        user:config.user,
-        password:config.password,
-        database:config.database,
-        charset:config.charset,
-      },
-      debug: config.debug,
-      //默认为{min: 2, max: 10}
-      pool: { 
-        min: 0,
-        max: 2,
-      },
-      log: {
-        warn(message) {
-          console.error("[knex warn]", message);
-        },
-        error(message) {
-          console.error("[knex error]", message);
-        },
-      },
-    });
-}
-/**
- * 
- * @param {*} module 模块目录
- * @returns Array 
- * @description 将web模块放到最后加载
- */
-export const loadWebToEnd = function(module=[]){
-  const index = module.indexOf('web');
-  if (index !== -1) {
-      const web = module.splice(index, 1);
-      module.push(web[0]);
-  }
-  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();
-};
-
-
-// 重新导出 deepmerge 的命名导出
-export { default as merge } from 'deepmerge';

package/core/lib/cache.js

@@ -1,133 +0,0 @@
-export default class Cache {
-    constructor(maxSize = 1000) {
-      this.cache = new Map(); // 使用 Map 存储缓存数据
-      this.maxSize = maxSize; // 缓存最大容量
-      this.hits = 0; // 缓存命中次数
-      this.misses = 0; // 缓存未命中次数
-    }
-  
-    /**
-     * 设置缓存
-     * @param {string} key - 缓存键
-     * @param {any} value - 缓存值
-     * @param {number} ttl - 缓存时间（毫秒），可选
-     */
-    set(key, value, ttl = null) {
-      // 如果缓存已满，删除最早的一个缓存项
-      if (this.cache.size >= this.maxSize) {
-        const firstKey = this.cache.keys().next().value;
-        this.cache.delete(firstKey);
-      }
-  
-      const cacheItem = {
-        value,
-        expires: ttl ? Date.now() + ttl : null, // 设置过期时间
-        updatedAt: Date.now(), // 记录更新时间
-      };
-      this.cache.set(key, cacheItem);
-    }
-  
-    /**
-     * 获取缓存
-     * @param {string} key - 缓存键
-     * @returns {any} - 缓存值，如果过期或不存在则返回 null
-     */
-    get(key) {
-      if (!this.cache.has(key)) {
-        this.misses++; // 未命中
-        return null;
-      }
-  
-      const cacheItem = this.cache.get(key);
-  
-      // 检查是否过期
-      if (cacheItem.expires && Date.now() > cacheItem.expires) {
-        this.cache.delete(key); // 删除过期缓存
-        this.misses++; // 未命中
-        return null;
-      }
-  
-      this.hits++; // 命中
-      return cacheItem.value; // 返回缓存值
-    }
-  
-    /**
-     * 清除指定缓存
-     * @param {string} key - 缓存键
-     */
-    clear(key) {
-      this.cache.delete(key);
-    }
-  
-    /**
-     * 清除所有缓存
-     */
-    clearAll() {
-      this.cache.clear();
-      this.hits = 0;
-      this.misses = 0;
-    }
-  
-    /**
-     * 获取缓存命中率
-     * @returns {number} - 命中率（0 到 1 之间）
-     */
-    getHitRate() {
-      const total = this.hits + this.misses;
-      return total === 0 ? 0 : this.hits / total;
-    }
-  
-    /**
-     * 获取缓存大小
-     * @returns {number} - 缓存项数量
-     */
-    size() {
-      return this.cache.size;
-    }
-  
-    /**
-     * 获取所有缓存键
-     * @returns {string[]} - 缓存键列表
-     */
-    keys() {
-      return Array.from(this.cache.keys());
-    }
-  
-    /**
-     * 遍历缓存项
-     * @param {function} callback - 回调函数，接收 key 和 value 作为参数
-     */
-    forEach(callback) {
-      this.cache.forEach((cacheItem, key) => {
-        callback(key, cacheItem.value);
-      });
-    }
-}
-
-  
-//   // 示例用法
-//   const cache = new SimpleCache(100); // 设置缓存最大容量为 100
-  
-//   // 设置缓存，有效期为 5 秒
-//   cache.set('name', 'Alice', 5000);
-//   cache.set('name', 'Alice', 5000);
-//   // 获取缓存
-//   console.log(cache.get('name')); // 输出: Alice
-  
-//   // 获取缓存命中率
-//   console.log(cache.getHitRate()); // 输出: 1 (100% 命中率)
-  
-//   // 获取缓存大小
-//   console.log(cache.size()); // 输出: 1
-  
-//   // 获取所有缓存键
-//   console.log(cache.keys()); // 输出: ['name']
-  
-//   // 遍历缓存项
-//   cache.forEach((key, value) => {
-//     console.log(`Key: ${key}, Value: ${value}`);
-//   });
-  
-//   // 清除所有缓存
-//   cache.clearAll();
-//   console.log(cache.size()); // 输出: 0

package/core/lib/controller.js

@@ -1,56 +0,0 @@
-export default class Controller {
-  constructor() {
-  }
-
- parseJsonFields(obj) {
-  const result = {};
-  for (const key in obj) {
-    if (!obj.hasOwnProperty(key)) continue;
-    const value = obj[key];
-    // 如果是字符串，并且看起来像 JSON（以 { 或 [ 开头）
-    if (typeof value === 'string' && (value.startsWith('{') || value.startsWith('['))) {
-      try {
-        result[key] = JSON.parse(value);
-      } catch (e) {
-        console.warn(`JSON parse failed for field: ${key}`, e);
-        result[key] = value; // 保留原始值
-      }
-    } else {
-      result[key] = value;
-    }
-  }
-
-  return result;
-}
-
-  success(data) {
-    return {
-        success: true,
-        msg: '操作成功',
-        code: 200,
-        data
-    };
-  }
-
-  fail(data, code = 201) {
-     return {
-        success: false,
-        msg: '操作失败',
-        code,
-        data
-    };
-  }
-
-
-  err(data={}, code = 500){
-    return {
-      success: false,
-      msg: '系统异常',
-      code,
-      data
-    };
-  }
-  
-
- 
-}

package/core/lib/index.js

@@ -1,32 +0,0 @@
-import express from "express";
-import cookieParser from "cookie-parser";
-import favicon from "serve-favicon";
-
-import morgan from "morgan";
-import path from "path";
-import view from "./view.js";
-export default async function (app, config) {
-  const { logger, APP_PATH, cookieKey, statics, JSON_LIMIT, appName, version } =
-    config;
-
-  app.use(morgan(logger.level));
-  app.use(favicon(path.join(APP_PATH, "public/favicon.ico")));
-  app.use(cookieParser(cookieKey));
-  app.use(express.json({ limit: JSON_LIMIT }));
-  app.use(express.urlencoded({ extended: false }));
-  view(app, config);
-  if (statics.length > 0) {
-    statics.forEach((item) => {
-      const { prefix, dir, maxAge } = item;
-      app.use(prefix, express.static(dir, { maxAge: maxAge || 0 }));
-    });
-  }
-
-  app.use((req, res, next) => {
-    res.setHeader("Create-By", "Chanjs");
-    res.setHeader("X-Powered-By", "ChanCMS");
-    res.setHeader("ChanCMS", version);
-    res.setHeader("Server", appName);
-    next();
-  });
-};

package/core/lib/service.js

@@ -1,269 +0,0 @@
-const errCode = {
-  "ECONNREFUSED": "数据库连接被拒绝，请检查数据库服务是否正常运行。",
-  "ER_ACCESS_DENIED_ERROR": "无权限访问，账号或密码错误。",
-  "ER_ROW_IS_REFERENCED_2": "无法删除或更新记录，存在关联数据。",
-  "ER_BAD_FIELD_ERROR": "SQL语句中包含无效字段，请检查查询条件或列名。",
-  "ER_DUP_ENTRY": "插入失败：数据重复，违反唯一性约束。",
-  "ER_NO_SUCH_TABLE": "操作失败：目标表不存在。",
-  "ETIMEOUT": "数据库操作超时，请稍后再试。"
-}
-const getDefaultErrorMessage = (error) => {
-  if (error.message.includes('syntax') ||
-    error.message.includes('SQL')) {
-    return '数据库语法错误，请检查您的查询语句。';
-  } else if (error.message.includes('Connection closed')) {
-    return '数据库连接已关闭，请重试。';
-  } else if (error.message.includes('permission')) {
-    return '数据库权限不足，请检查配置。';
-  }
-  return '数据库发生未知错误，请稍后重试。';
-}
-
-class BaseService {
-  /**
-   * @description 构造函数
-   * @param {*} knex - knex实例
-   */
-  constructor(DB = Chan.knex) {
-    this.knex = DB;
-    this.DB = DB;
-    this.model = ''; // 默认为空字符串
-  }
-
-  /**
-  * @description 查询表所有记录，慎用
-  * @param {Object} query - 包含查询参数的对象
-  * @returns {Promise} 返回所有记录
-  */
-  async all(query = {}) {
-    try {
-      let dbQuery = this.DB(this.model);
-      if (Object.keys(query).length > 0) {
-        dbQuery = dbQuery.where(query);
-      }
-      let res = await dbQuery.select();
-      return this.success(res);
-    } catch (err) {
-      return this.error(err);
-    }
-  }
-
-  /**
-  * @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 }) {
-    try {
-      let dataQuery = this.DB(this.model).where(query);
-      if (field.length > 0) {
-        dataQuery = dataQuery.select(field);
-      }
-      if (len === 1) {
-        dataQuery = dataQuery.first();
-      } else if (len > 1) {
-        dataQuery = dataQuery.limit(len);
-      }
-      let res = await dataQuery;
-      console.log('111',res);
-      return this.success(res || (len === 1 ? {} : []));
-    } catch (err) {
-      return this.error(err);
-    }
-  }
-
-
-  /**
-   * @description 创建新记录
-   * @param {Object} data - 包含要插入的数据对象
-   * @returns {Promise<boolean>} 返回操作是否成功
-   */
-  async insert(data = {}) {
-    try {
-      if (Object.keys(data).length === 0) {
-        return this.fail('插入数据不能为空');
-      }
-      const result = await this.DB(this.model).insert(data);
-      return this.success(result?.length > 0 || !!result)
-    } catch (err) {
-      return this.error(err); // 假设你有 this.error() 的封装
-    }
-  }
-
-  /**
- * @description 插入多条记录
- * @param {Array} records - 包含要插入的数据对象数组 [{<key>:<value>}, {<key>:<value>}, ...]
- * @returns {Promise<Array|Number>} 返回插入后的记录或受影响行数，具体取决于数据库驱动
- */
-  async insertMany(records = []) {
-    try {
-      if (records.length === 0) {
-        return this.fail('插入数据不能为空');
-      }
-      const result = await this.DB(this.model).insert(records);
-      return this.success(result)
-    } catch (err) {
-      return this.error(err); // 假设你有 this.error() 的封装
-    }
-  }
-
-  /**
-  * @description 根据指定条件删除记录
-  * @param {Object} query - 包含查询条件的对象
-  * @returns {Promise<boolean>} 返回操作是否成功（即是否有任何记录被删除）
-  */
-  async delete(query = {}) {
-    try {
-      if (Object.keys(query).length === 0) {
-        return this.error("请指定删除条件");
-      }
-      const affectedRows = await this.DB(this.model).where(query).del();
-      return this.success(affectedRows > 0);
-    } catch (err) {
-      return this.error(err); // 假设你有 this.error() 的封装
-    }
-  }
-  /**
-   * @description 根据指定条件更新记录
-   * @param {Object} query - 查询条件
-   * @param {Object} params - 要更新的数据
-   * @returns {Promise<boolean>} 返回操作是否成功（是否有行被更新）
-   */
-  async update({ query, params } = {}) {
-    try {
-      console.log('update--->',query, params)
-      if (!query || !params || Object.keys(query).length === 0) {
-        return this.fail("参数错误");
-      }
-      const result = await this.DB(this.model).where(query).update(params);
-      return this.success(!!result);
-    } catch (err) {
-      return this.error(err); // 假设你有 this.error() 的封装
-    }
-  }
-
-  /**
-   * @description 批量更新多条记录（基于事务保证原子性）
-   * @param {Array<{query: Object, params: Object}>} updates - 更新操作数组
-   * @returns {Promise<boolean>} 返回是否所有记录都更新成功
-   */
-  async updateMany(updates = []) {
-    if (!Array.isArray(updates)) {
-      return this.fail('参数必须为数组格式');
-    }
-    // 获取事务对象
-    const trx = await this.DB.transaction();
-    try {
-      for (const { query, params } of updates) {
-        const result = await trx(this.model).where(query).update(params);
-        if (result === 0) {
-          await trx.rollback(); // 有一条失败就回滚
-          return this.fail('更新失败');
-        }
-      }
-
-      await trx.commit();
-      return this.success(true);
-    } catch (err) {
-      await trx.rollback();
-      return this.error(error);
-    }
-  }
-
-  /**
-  * 查找所有符合条件的记录，并提供分页信息。
-  * @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 = [] }) {
-    try {
-      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);
-      }
-      //并行执行获取总记录数和分页数据的查询
-      const [totalResult, list] = await Promise.all([countQuery.first(), dataQuery.offset(offset).limit(pageSize)]);
-      // 提取总记录数
-      const total = totalResult?.total || 0;
-      return this.success({ list, total, current, pageSize });
-    } catch (err) { }
-    return this.error(err);
-  }
-
-
-  /**
-  * @description 查询指定条件的记录数量
-  * @param {Array} query - 数组形式的多个条件 [{<key>:<value>}, {<key>:<value>}, ...]
-  * @returns {Promise<number>} 返回符合条件的记录数量
-  */
-  async count(query = []) {
-    try {
-      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 this.success(result?.total || 0);
-    } catch (error) {
-      return this.error(error);
-    }
-  }
-
-
-  error(err) {
-    console.error('-->',err);
-    // 从映射表中查找对应的错误信息
-    const message = errCode[err.code] || getDefaultErrorMessage(err);
-    return {
-      success: false,
-      msg: message,
-      code: 500, // 或者根据错误类型区分
-      data: {
-        sql: err.sql,
-        sqlMessage: err.sqlMessage
-      }
-    };
-  }
-
-  fail(msg = "操作失败", data = {}) {
-    console.error(msg);
-    return {
-      success: false,
-      msg,
-      code: 201, // 或者根据错误类型区分
-      data: data
-    }
-  }
-
-  success(data = {}, msg = "操作成功") {
-    return {
-      success: true,
-      msg,
-      code: 200,
-      data
-    }
-  }
-
-}
-export default BaseService;