mm_os 4.3.6 → 4.3.7

package/core/store/index.js

@@ -1,6 +1,6 @@
-const { Drive } = require("mm_machine");
-const { idGen } = require("../../ulits/id_gen.js");
-const Sql = require("./sql.js");
+const { Drive } = require('mm_machine');
+const { idGen } = require('../../ulits/id_gen.js');
+const Sql = require('../../com/sql/drive.js');
 
 /**
  * 数据存储基类
@@ -13,8 +13,8 @@ class Store extends Drive {
    * @returns {boolean} 配置是否有效
    */
   static validateConfig(config) {
-    if (!config || typeof config !== "object") {
-      throw new TypeError("配置参数必须是对象");
+    if (!config || typeof config !== 'object') {
+      throw new TypeError('配置参数必须是对象');
     }
 
     Store._validateReqFields(config);
@@ -31,7 +31,7 @@ class Store extends Drive {
    * @param {object} config 配置参数
    */
   static _validateReqFields(config) {
-    var required_fields = ["name", "cache_type", "save_type", "way", "table"];
+    var required_fields = ['name', 'cache_type', 'save_type', 'way', 'table'];
     for (var field of required_fields) {
       if (!config[field]) {
         throw new Error(`配置参数缺少必要字段: ${field}`);
@@ -44,7 +44,7 @@ class Store extends Drive {
    * @param {object} config 配置参数
    */
   static _validateCacheType(config) {
-    var valid_cache_types = ["none", "memory", "redis", "mongodb"];
+    var valid_cache_types = ['none', 'memory', 'redis', 'mongodb'];
     if (!valid_cache_types.includes(config.cache_type)) {
       throw new Error(`无效的缓存类型: ${config.cache_type}`);
     }
@@ -55,7 +55,7 @@ class Store extends Drive {
    * @param {object} config 配置参数
    */
   static _validateSaveType(config) {
-    var valid_save_types = ["none", "sqlite", "mysql", "json"];
+    var valid_save_types = ['none', 'sqlite', 'mysql', 'json'];
     if (!valid_save_types.includes(config.save_type)) {
       throw new Error(`无效的保存类型: ${config.save_type}`);
     }
@@ -76,11 +76,11 @@ class Store extends Drive {
    * @param {object} config 配置参数
    */
   static _validateNumFields(config) {
-    var numeric_fields = ["cache_interval", "save_interval", "page_size"];
+    var numeric_fields = ['cache_interval', 'save_interval', 'page_size'];
     for (var num_field of numeric_fields) {
       if (
         config[num_field] &&
-        (typeof config[num_field] !== "number" || config[num_field] < 0)
+        (typeof config[num_field] !== 'number' || config[num_field] < 0)
       ) {
         throw new Error(`${num_field} 必须是正数`);
       }
@@ -89,23 +89,23 @@ class Store extends Drive {
 
   static config = {
     // 名称
-    name: "default",
+    name: 'default',
     // 标题
-    title: "示例标题",
+    title: '示例标题',
     // 描述
-    description: "示例描述",
+    description: '示例描述',
     // 入口文件
-    main: "",
+    main: '',
     // 作用域，决定加载到什么区域
-    scope: "server",
+    scope: 'server',
     // 状态 0：禁用 1：启用
     state: 1,
     // 排序，越小越靠前
     sort: 100,
     // 缓存方式 none、memory、redis、mongodb
-    cache_type: "none",
+    cache_type: 'none',
     // 保存方式 none、sqlite、mysql、json
-    save_type: "none",
+    save_type: 'none',
     // 缓存更新间隔（秒）
     cache_interval: 600, // 默认10分钟
     // 定时持久化间隔（秒）
@@ -113,61 +113,61 @@ class Store extends Drive {
     // 读写方式 1.直接读写数据库；2.读缓存，写持久存，写后更新缓存；3.读缓存，写缓存，定时持久存；4.读缓存，写持久存，定时更新缓存
     way: 1,
     // 表名
-    table: "store",
+    table: 'store',
     // 主键
-    key: "id",
+    key: 'id',
     // ID
-    id: "id",
+    id: 'id',
     // 默认分页大小
     page_size: 30,
     // 排序方式，{0}表示支持前端传值来排序，传值方式例如：orderby=user_id
-    orderby: "{0}",
+    orderby: '{0}',
     // 默认排序方式，当前端没有传值的情况下，采用默认传值方式
-    orderby_default: "`user_id` desc",
+    orderby_default: '`user_id` desc',
     // 查询列表时返回的字段，{0}表示支持前端传值
-    field: "{0}",
+    field: '{0}',
     // 查询对象时返回的字段
-    field_obj: "{0}",
+    field_obj: '{0}',
     // 默认返回字段
-    field_default: "`username`, `phone`",
+    field_default: '`username`, `phone`',
     // 需要过滤的字段，*代表泛匹配 前面*表示以xxx结尾，后面*表示以xxx开头，前后*表示包含xxx的过滤
-    field_hide: ["*password*", "*token*"],
+    field_hide: ['*password*', '*token*'],
     // 传值分隔符，如果允许多个值，可以通过这个来分割，如果不允许传多个值则设置为空
-    separator: "|",
+    separator: '|',
     // 过滤参数
     filter: {
       /**
        * 表名
        */
-      table: "table",
+      table: 'table',
       /**
        * 查询的页码
        */
-      page: "page",
+      page: 'page',
       /**
        * 查询每页条数
        */
-      size: "size",
+      size: 'size',
       /**
        * 操作方式: 传入参数method=add, 支持参数 add增、del删、set改、get查，为空则为get
        */
-      method: "method",
+      method: 'method',
       /**
        * 排序
        */
-      orderby: "orderby",
+      orderby: 'orderby',
       /**
        * 查询显示的字段
        */
-      field: "field",
+      field: 'field',
       /**
        * 统计结果: 统计符合条件的结果数，只有当page等于1或0时才会统计
        */
-      count_ret: "count_ret",
+      count_ret: 'count_ret',
     },
     // 允许调用的方法 add增 del删 set改 get查 get_obj查一条 import导入 export导出, 支持什么方式就传什么值，支持多个用空格分隔
     method:
-      "add del set get get_obj import export del_repeat avg sum count update",
+      'add del set get get_obj import export del_repeat avg sum count update',
     // sql查询语句
     query: {
       // 当username=xx时，转为`username` like '%xxx%'的SQL语法
@@ -187,9 +187,9 @@ class Store extends Drive {
     // 输出sql语句
     log: false,
     // 文件路径, 当调用函数不存在时，会先从文件中加载
-    main: "",
+    main: '',
     // 回调函数名 用于决定调用脚本的哪个函数
-    func_name: "",
+    func_name: '',
     // 参数 []
     params: null,
     // 导入导出格式，转换导入、导出Eexcel时字段名和字段值
@@ -197,9 +197,9 @@ class Store extends Drive {
     // 去重条件，需要查重、并去重的字段在这里写
     del_repeat: {
       // 判断重复的字段
-      groupBy: "",
+      groupby: '',
       // 排序方式
-      orderBy: "",
+      orderby: '',
     },
   };
 
@@ -212,7 +212,7 @@ class Store extends Drive {
     // 验证配置参数
     Store.validateConfig({ ...Store.config, ...config });
 
-    super({ type: "store", ...Store.config, ...config }, parent);
+    super({ type: 'store', ...Store.config, ...config }, parent);
   }
 }
 
@@ -275,7 +275,7 @@ Store.prototype._initCore = async function (db, cache, logger) {
  */
 Store.prototype._addToDb = async function (body) {
   let db = this._sql.db();
-  return await this._drive.add(db, body);
+  return await this._drive.add(db, {}, body);
 };
 
 /**
@@ -292,8 +292,8 @@ Store.prototype._addToCache = async function (body) {
   };
 
   // 保存到缓存
-  let cache_key = this._genCacheKey("get", {});
-  let cache_obj_key = this._genCacheKey("getObj", { [this.config.id]: temp });
+  let cache_key = this._genCacheKey('get', {});
+  let cache_obj_key = this._genCacheKey('getObj', { [this.config.id]: temp });
 
   // 获取当前列表缓存
   let current = (await this.getCache(cache_key)) || [];
@@ -313,19 +313,19 @@ Store.prototype._addToCache = async function (body) {
  */
 Store.prototype.add = async function (body) {
   // 入参校验
-  if (typeof body !== "object" || body === null) {
-    throw new TypeError("添加的数据必须是对象");
+  if (typeof body !== 'object' || body === null) {
+    throw new TypeError('添加的数据必须是对象');
   }
   if (Object.keys(body).length === 0) {
-    throw new TypeError("添加的数据不能为空");
+    throw new TypeError('添加的数据不能为空');
   }
 
   try {
     let way = this.config.way;
     return await this._addByWay(body, way);
   } catch (error) {
-    this.log("error", "创建数据失败:", error);
-    return $.ret.error(error.code || 500, "创建数据失败");
+    this.log('error', '创建数据失败:', error);
+    return $.ret.error(error.code || 500, '创建数据失败');
   }
 };
 
@@ -373,19 +373,19 @@ Store.prototype._addListToDb = async function (list) {
  * @returns {Promise<object>} - 添加结果
  */
 Store.prototype._addListToCache = async function (list) {
-  let cache_key = this._genCacheKey("get", {});
+  let cache_key = this._genCacheKey('get', {});
   let current = (await this.getCache(cache_key)) || [];
 
   // 为每条数据生成临时ID
   let cached = list.map((item) => {
-    let temp = item[this.config.id] || idGen.genId("temp");
+    let temp = item[this.config.id] || idGen.genId('temp');
     let data = {
       ...item,
       [this.config.id]: temp,
     };
 
     // 设置单条数据缓存
-    let cache_obj_key = this._genCacheKey("getObj", { [this.config.id]: temp });
+    let cache_obj_key = this._genCacheKey('getObj', { [this.config.id]: temp });
     this.setCache(cache_obj_key, data);
 
     return data;
@@ -413,10 +413,10 @@ Store.prototype._addListToCache = async function (list) {
 Store.prototype.addList = async function (list) {
   // 入参校验
   if (!Array.isArray(list)) {
-    throw new TypeError("批量添加的数据必须是数组");
+    throw new TypeError('批量添加的数据必须是数组');
   }
   if (list.length === 0) {
-    throw new TypeError("批量添加的数据不能为空");
+    throw new TypeError('批量添加的数据不能为空');
   }
 
   try {
@@ -436,14 +436,14 @@ Store.prototype.addList = async function (list) {
     // 方式2：写后更新缓存
     if (way === 2 && this._cache && result.result) {
       // 清除列表缓存，下次读取时会自动更新
-      let cache_key = this._genCacheKey("get", {});
+      let cache_key = this._genCacheKey('get', {});
       await this.delCache(cache_key);
     }
 
     return this._formatAddListRet(result, list.length);
   } catch (error) {
-    this.log("error", "批量创建数据失败:", error);
-    return { error: true, message: "批量创建数据失败" };
+    this.log('error', '批量创建数据失败:', error);
+    return { error: true, message: '批量创建数据失败' };
   }
 };
 
@@ -507,12 +507,12 @@ Store.prototype._getFromDb = async function (query) {
  */
 Store.prototype.getObj = async function (query = {}) {
   // 入参校验
-  if (typeof query !== "object" || query === null) {
-    throw new TypeError("查询条件必须是对象");
+  if (typeof query !== 'object' || query === null) {
+    throw new TypeError('查询条件必须是对象');
   }
 
   let way = this.config.way;
-  let cache_key = this._genCacheKey("getObj", query);
+  let cache_key = this._genCacheKey('getObj', query);
 
   // 尝试从缓存读取
   let cached = await this._tryGetFromCache(cache_key, way);
@@ -536,8 +536,8 @@ Store.prototype.getObj = async function (query = {}) {
  */
 Store.prototype.get = async function (query = {}) {
   // 入参校验
-  if (typeof query !== "object" || query === null) {
-    throw new TypeError("查询条件必须是对象");
+  if (typeof query !== 'object' || query === null) {
+    throw new TypeError('查询条件必须是对象');
   }
 
   return await this._getCache(query);
@@ -551,7 +551,7 @@ Store.prototype.get = async function (query = {}) {
  */
 Store.prototype._getCache = async function (query) {
   let way = this.config.way;
-  let cache_key = this._genCacheKey("get", query);
+  let cache_key = this._genCacheKey('get', query);
 
   // 尝试从缓存读取
   let cached = await this._tryGetListFromCache(cache_key, way);
@@ -575,10 +575,10 @@ Store.prototype._getCache = async function (query) {
  * @param {string} fields - 查询字段
  * @returns {Promise<object|null>} - 查询到的数据对象或null
  */
-Store.prototype.getById = async function (id, orderby = "", fields = "") {
+Store.prototype.getById = async function (id, orderby = '', fields = '') {
   // 入参校验
   if (!id && id !== 0) {
-    throw new TypeError("ID不能为空");
+    throw new TypeError('ID不能为空');
   }
 
   return await this._getByIdCache(id, orderby, fields);
@@ -595,7 +595,7 @@ Store.prototype.getById = async function (id, orderby = "", fields = "") {
 Store.prototype._getByIdCache = async function (id, orderby, fields) {
   let way = this.config.way;
   let query = this._buildQueryById(id);
-  let cache_key = this._genCacheKey("getObj", query);
+  let cache_key = this._genCacheKey('getObj', query);
 
   // 尝试从缓存读取
   let cached = await this._tryGetFromCache(cache_key, way);
@@ -629,8 +629,8 @@ Store.prototype.set = async function (query, body) {
   this._validateSet(query, body);
 
   let way = this.config.way;
-  let cache_key = this._genCacheKey("get", query);
-  let cache_obj_key = this._genCacheKey("getObj", query);
+  let cache_key = this._genCacheKey('get', query);
+  let cache_obj_key = this._genCacheKey('getObj', query);
 
   let result = await this._runSetByWay(
     way,
@@ -651,14 +651,14 @@ Store.prototype.set = async function (query, body) {
  * @throws {TypeError} 参数验证失败时抛出
  */
 Store.prototype._checkSet = function (query, body) {
-  if (typeof query !== "object" || query === null) {
-    throw new TypeError("查询条件必须是对象");
+  if (typeof query !== 'object' || query === null) {
+    throw new TypeError('查询条件必须是对象');
   }
-  if (typeof body !== "object" || body === null) {
-    throw new TypeError("更新内容必须是对象");
+  if (typeof body !== 'object' || body === null) {
+    throw new TypeError('更新内容必须是对象');
   }
   if (Object.keys(body).length === 0) {
-    throw new TypeError("更新内容不能为空");
+    throw new TypeError('更新内容不能为空');
   }
 };
 
@@ -781,7 +781,7 @@ Store.prototype.setCacheExpire = async function (key, expire_time) {
     await this._cache.expire(key, expire_time);
     return true;
   } catch (error) {
-    this.log("error", "设置缓存失效时间失败:", error);
+    this.log('error', '设置缓存失效时间失败:', error);
     return false;
   }
 };
@@ -801,7 +801,7 @@ Store.prototype.setCache = async function (action, params, data) {
   try {
     return await this._updateCache(action, params, data);
   } catch (error) {
-    this.log("error", "更新缓存失败:", error);
+    this.log('error', '更新缓存失败:', error);
     return false;
   }
 };
@@ -829,13 +829,13 @@ Store.prototype._setCache = async function (action, params, data) {
 Store.prototype.setById = async function (id, body) {
   // 入参校验
   if (!id && id !== 0) {
-    throw new TypeError("ID不能为空");
+    throw new TypeError('ID不能为空');
   }
-  if (typeof body !== "object" || body === null) {
-    throw new TypeError("更新内容必须是对象");
+  if (typeof body !== 'object' || body === null) {
+    throw new TypeError('更新内容必须是对象');
   }
   if (Object.keys(body).length === 0) {
-    throw new TypeError("更新内容不能为空");
+    throw new TypeError('更新内容不能为空');
   }
 
   let way = this.config.way;
@@ -867,8 +867,8 @@ Store.prototype._buildGetById = function (id) {
  */
 Store.prototype._genCacheKeysForId = function (query) {
   return {
-    list_key: this._genCacheKey("get", query),
-    obj_key: this._genCacheKey("getObj", query),
+    list_key: this._genCacheKey('get', query),
+    obj_key: this._genCacheKey('getObj', query),
   };
 };
 
@@ -974,16 +974,16 @@ Store.prototype._clearCacheSetById = async function (cache_key, cache_obj_key) {
  */
 Store.prototype.del = async function (query) {
   // 入参校验
-  if (typeof query !== "object" || query === null) {
-    throw new TypeError("查询条件必须是对象");
+  if (typeof query !== 'object' || query === null) {
+    throw new TypeError('查询条件必须是对象');
   }
   if (Object.keys(query).length === 0) {
-    throw new TypeError("查询条件不能为空");
+    throw new TypeError('查询条件不能为空');
   }
 
   let way = this.config.way;
-  let cache_key = this._genCacheKey("get", query);
-  let cache_obj_key = this._genCacheKey("getObj", query);
+  let cache_key = this._genCacheKey('get', query);
+  let cache_obj_key = this._genCacheKey('getObj', query);
 
   let affected_rows = 0;
 
@@ -1065,7 +1065,7 @@ Store.prototype._clearCacheAfterDel = async function (
   await this.delCache(cache_obj_key);
 
   // 清除空查询的列表缓存
-  let all_cache_key = this._genCacheKey("get", {});
+  let all_cache_key = this._genCacheKey('get', {});
   await this.delCache(all_cache_key);
 };
 
@@ -1077,7 +1077,7 @@ Store.prototype._clearCacheAfterDel = async function (
 Store.prototype.delById = async function (id) {
   // 入参校验
   if (!id && id !== 0) {
-    throw new TypeError("ID不能为空");
+    throw new TypeError('ID不能为空');
   }
 
   try {
@@ -1085,8 +1085,8 @@ Store.prototype.delById = async function (id) {
     // 构建查询条件
     const query = { [this.config.id]: id };
 
-    let cache_key = this._genCacheKey("get", query);
-    let cache_obj_key = this._genCacheKey("getObj", query);
+    let cache_key = this._genCacheKey('get', query);
+    let cache_obj_key = this._genCacheKey('getObj', query);
 
     let affected_rows = 0;
 
@@ -1107,7 +1107,7 @@ Store.prototype.delById = async function (id) {
 
     return affected_rows;
   } catch (error) {
-    this.log("error", "根据ID删除数据失败:", error);
+    this.log('error', '根据ID删除数据失败:', error);
     return 0;
   }
 };
@@ -1136,7 +1136,7 @@ Store.prototype._delByIdDb = async function (query) {
  */
 Store.prototype._delByIdCache = async function (id, cache_key, cache_obj_key) {
   // 从缓存获取当前数据
-  let all_cache_key = this._genCacheKey("get", {});
+  let all_cache_key = this._genCacheKey('get', {});
   let cached = await this.getCache(all_cache_key);
   let affected_rows = 0;
 
@@ -1172,7 +1172,7 @@ Store.prototype._clearCacheAfterDel = async function (
   await this.delCache(cache_obj_key);
 
   // 清除空查询的列表缓存
-  let all_cache_key = this._genCacheKey("get", {});
+  let all_cache_key = this._genCacheKey('get', {});
   await this.delCache(all_cache_key);
 };
 
@@ -1183,19 +1183,19 @@ Store.prototype._clearCacheAfterDel = async function (
  */
 Store.prototype.count = async function (query = {}) {
   // 入参校验
-  if (typeof query !== "object" || query === null) {
-    throw new TypeError("查询条件必须是对象");
+  if (typeof query !== 'object' || query === null) {
+    throw new TypeError('查询条件必须是对象');
   }
 
   try {
     let db = this._sql.db();
     db.table = this.config.table;
-    db.count_ret = "true";
+    db.count_ret = 'true';
 
-    let result = await this._drive.getMain(db, query, "count");
+    let result = await this._drive.getMain(db, query, 'count');
     return result.result ? result.result.count : 0;
   } catch (error) {
-    this.log("error", "统计数据失败:", error);
+    this.log('error', '统计数据失败:', error);
     return 0;
   }
 };
@@ -1208,8 +1208,8 @@ Store.prototype.count = async function (query = {}) {
  */
 Store.prototype.sum = async function (query, field) {
   // 入参校验
-  if (!field || typeof field !== "string") {
-    throw new TypeError("字段名必须是字符串");
+  if (!field || typeof field !== 'string') {
+    throw new TypeError('字段名必须是字符串');
   }
 
   try {
@@ -1217,7 +1217,7 @@ Store.prototype.sum = async function (query, field) {
     db.table = this.config.table;
     return await db.sum(query, field);
   } catch (error) {
-    this.log("error", "统计字段总和失败:", error);
+    this.log('error', '统计字段总和失败:', error);
     return 0;
   }
 };
@@ -1230,8 +1230,8 @@ Store.prototype.sum = async function (query, field) {
  */
 Store.prototype.avg = async function (query, field) {
   // 入参校验
-  if (!field || typeof field !== "string") {
-    throw new TypeError("字段名必须是字符串");
+  if (!field || typeof field !== 'string') {
+    throw new TypeError('字段名必须是字符串');
   }
 
   try {
@@ -1239,7 +1239,7 @@ Store.prototype.avg = async function (query, field) {
     db.table = this.config.table;
     return await db.avg(query, field);
   } catch (error) {
-    this.log("error", "统计字段平均值失败:", error);
+    this.log('error', '统计字段平均值失败:', error);
     return 0;
   }
 };
@@ -1252,8 +1252,8 @@ Store.prototype.avg = async function (query, field) {
  */
 Store.prototype.max = async function (query, field) {
   // 入参校验
-  if (!field || typeof field !== "string") {
-    throw new TypeError("字段名必须是字符串");
+  if (!field || typeof field !== 'string') {
+    throw new TypeError('字段名必须是字符串');
   }
 
   try {
@@ -1261,7 +1261,7 @@ Store.prototype.max = async function (query, field) {
     db.table = this.config.table;
     return await db.max(query, field);
   } catch (error) {
-    this.log("error", "统计字段最大值失败:", error);
+    this.log('error', '统计字段最大值失败:', error);
     return 0;
   }
 };
@@ -1274,8 +1274,8 @@ Store.prototype.max = async function (query, field) {
  */
 Store.prototype.min = async function (query, field) {
   // 入参校验
-  if (!field || typeof field !== "string") {
-    throw new TypeError("字段名必须是字符串");
+  if (!field || typeof field !== 'string') {
+    throw new TypeError('字段名必须是字符串');
   }
 
   try {
@@ -1283,7 +1283,7 @@ Store.prototype.min = async function (query, field) {
     db.table = this.config.table;
     return await db.min(query, field);
   } catch (error) {
-    this.log("error", "统计字段最小值失败:", error);
+    this.log('error', '统计字段最小值失败:', error);
     return 0;
   }
 };
@@ -1295,10 +1295,10 @@ Store.prototype.min = async function (query, field) {
  * @param {string} orderby - 排序字段
  * @returns {Promise<Array>} - 查询结果数组
  */
-Store.prototype.distinct = async function (query = {}, field, orderby = "") {
+Store.prototype.distinct = async function (query = {}, field, orderby = '') {
   // 入参校验
-  if (!field || typeof field !== "string") {
-    throw new TypeError("去重字段必须是字符串");
+  if (!field || typeof field !== 'string') {
+    throw new TypeError('去重字段必须是字符串');
   }
 
   try {
@@ -1306,7 +1306,7 @@ Store.prototype.distinct = async function (query = {}, field, orderby = "") {
     db.table = this.config.table;
     return await db.distinct(query, field, orderby);
   } catch (error) {
-    this.log("error", "去重查询数据失败:", error);
+    this.log('error', '去重查询数据失败:', error);
     return [];
   }
 };
@@ -1322,12 +1322,12 @@ Store.prototype.distinct = async function (query = {}, field, orderby = "") {
 Store.prototype.group = async function (
   query,
   groupby,
-  fields = "*",
-  orderby = "",
+  fields = '*',
+  orderby = '',
 ) {
   // 入参校验
-  if (!groupby || typeof groupby !== "string") {
-    throw new TypeError("分组字段必须是字符串");
+  if (!groupby || typeof groupby !== 'string') {
+    throw new TypeError('分组字段必须是字符串');
   }
 
   try {
@@ -1335,7 +1335,7 @@ Store.prototype.group = async function (
     db.table = this.config.table;
     return await db.group(query, groupby, fields, orderby);
   } catch (error) {
-    this.log("error", "分组查询数据失败:", error);
+    this.log('error', '分组查询数据失败:', error);
     return [];
   }
 };
@@ -1349,7 +1349,7 @@ Store.prototype.begin = async function () {
     let db = this._sql.db();
     return await db.begin();
   } catch (error) {
-    this.log("error", "开始事务失败:", error);
+    this.log('error', '开始事务失败:', error);
     return null;
   }
 };
@@ -1362,14 +1362,14 @@ Store.prototype.begin = async function () {
 Store.prototype.commit = async function (txn) {
   // 入参校验
   if (!txn) {
-    throw new TypeError("事务对象不能为空");
+    throw new TypeError('事务对象不能为空');
   }
 
   try {
     let db = this._sql.db();
     return await db.commit(txn);
   } catch (error) {
-    this.log("error", "提交事务失败:", error);
+    this.log('error', '提交事务失败:', error);
     return false;
   }
 };
@@ -1382,14 +1382,14 @@ Store.prototype.commit = async function (txn) {
 Store.prototype.rollback = async function (txn) {
   // 入参校验
   if (!txn) {
-    throw new TypeError("事务对象不能为空");
+    throw new TypeError('事务对象不能为空');
   }
 
   try {
     let db = this._sql.db();
     return await db.rollback(txn);
   } catch (error) {
-    this.log("error", "回滚事务失败:", error);
+    this.log('error', '回滚事务失败:', error);
     return false;
   }
 };
@@ -1402,7 +1402,7 @@ Store.prototype.rollback = async function (txn) {
 Store.prototype.getCache = async function (key) {
   // 入参校验
   if (!key) {
-    throw new TypeError("缓存键名不能为空");
+    throw new TypeError('缓存键名不能为空');
   }
 
   try {
@@ -1411,7 +1411,7 @@ Store.prototype.getCache = async function (key) {
     }
     return null;
   } catch (error) {
-    this.log("error", "获取缓存失败:", error);
+    this.log('error', '获取缓存失败:', error);
     return null;
   }
 };
@@ -1426,7 +1426,7 @@ Store.prototype.getCache = async function (key) {
 Store.prototype.setCache = async function (key, value, expire = 3600) {
   // 入参校验
   if (!key) {
-    throw new TypeError("缓存键名不能为空");
+    throw new TypeError('缓存键名不能为空');
   }
 
   try {
@@ -1435,7 +1435,7 @@ Store.prototype.setCache = async function (key, value, expire = 3600) {
     }
     return false;
   } catch (error) {
-    this.log("error", "设置缓存失败:", error);
+    this.log('error', '设置缓存失败:', error);
     return false;
   }
 };
@@ -1448,7 +1448,7 @@ Store.prototype.setCache = async function (key, value, expire = 3600) {
 Store.prototype.delCache = async function (key) {
   // 入参校验
   if (!key) {
-    throw new TypeError("缓存键名不能为空");
+    throw new TypeError('缓存键名不能为空');
   }
 
   try {
@@ -1457,7 +1457,7 @@ Store.prototype.delCache = async function (key) {
     }
     return false;
   } catch (error) {
-    this.log("error", "删除缓存失败:", error);
+    this.log('error', '删除缓存失败:', error);
     return false;
   }
 };
@@ -1471,7 +1471,7 @@ Store.prototype.delCache = async function (key) {
 Store.prototype._genCacheKey = function (action, params = {}) {
   let base = `${this.config.table}:${action}`;
 
-  if (!params || typeof params !== "object") {
+  if (!params || typeof params !== 'object') {
     return base;
   }
 
@@ -1479,7 +1479,7 @@ Store.prototype._genCacheKey = function (action, params = {}) {
   let sorted = Object.keys(params)
     .sort()
     .map((key) => `${key}:${JSON.stringify(params[key])}`)
-    .join("_");
+    .join('_');
 
   return `${base}:${sorted}`;
 };
@@ -1526,11 +1526,11 @@ Store.prototype._startSaveTimer = function () {
   // 定时将缓存数据持久化到数据库
   this._save_timer = setInterval(() => {
     this._saveCacheToDb().catch((error) => {
-      this.log("error", "定时持久化数据失败:", error);
+      this.log('error', '定时持久化数据失败:', error);
     });
   }, this._save_interval * 1000);
 
-  this.log("info", `已启动定时持久化定时器，间隔${this._save_interval}秒`);
+  this.log('info', `已启动定时持久化定时器，间隔${this._save_interval}秒`);
 };
 
 /**
@@ -1540,11 +1540,11 @@ Store.prototype._startCacheTimer = function () {
   // 定时从数据库更新缓存
   this._cache_timer = setInterval(() => {
     this._updateCacheFromDb().catch((error) => {
-      this.log("error", "定时更新缓存失败:", error);
+      this.log('error', '定时更新缓存失败:', error);
     });
   }, this._cache_interval * 1000);
 
-  this.log("info", `已启动定时更新缓存定时器，间隔${this._cache_interval}秒`);
+  this.log('info', `已启动定时更新缓存定时器，间隔${this._cache_interval}秒`);
 };
 
 /**
@@ -1554,7 +1554,7 @@ Store.prototype._startCacheTimer = function () {
 Store.prototype._saveCacheToDb = async function () {
   try {
     // 获取缓存中的所有数据
-    let cache_key = this._genCacheKey("get", {});
+    let cache_key = this._genCacheKey('get', {});
     let cached = await this.getCache(cache_key);
 
     if (!cached || !Array.isArray(cached)) {
@@ -1567,9 +1567,9 @@ Store.prototype._saveCacheToDb = async function () {
     // 批量保存数据到数据库
     await this._drive.addList(db, cached);
 
-    this.log("info", `成功持久化${cached.length}条数据到数据库`);
+    this.log('info', `成功持久化${cached.length}条数据到数据库`);
   } catch (error) {
-    this.log("error", "持久化缓存到数据库失败:", error);
+    this.log('error', '持久化缓存到数据库失败:', error);
     throw error;
   }
 };
@@ -1588,20 +1588,20 @@ Store.prototype._setCacheFromDb = async function () {
     let data = result.result ? result.result.list : [];
 
     // 更新缓存
-    let cache_key = this._genCacheKey("get", {});
+    let cache_key = this._genCacheKey('get', {});
     await this.setCache(cache_key, data);
 
     // 更新单条数据缓存
     for (let item of data) {
-      let cache_obj_key = this._genCacheKey("getObj", {
+      let cache_obj_key = this._genCacheKey('getObj', {
         [this.config.id]: item[this.config.id],
       });
       await this.setCache(cache_obj_key, item);
     }
 
-    this.log("info", `成功从数据库更新${data.length}条数据到缓存`);
+    this.log('info', `成功从数据库更新${data.length}条数据到缓存`);
   } catch (error) {
-    this.log("error", "从数据库更新缓存失败:", error);
+    this.log('error', '从数据库更新缓存失败:', error);
     throw error;
   }
 };
@@ -1691,7 +1691,7 @@ Store.prototype._updateCacheForWay2 = async function (data) {
     return;
   }
 
-  let cache_key = this._genCacheKey("get", {});
+  let cache_key = this._genCacheKey('get', {});
   let cached = (await this.getCache(cache_key)) || [];
 
   // 查找是否已存在
@@ -1722,7 +1722,7 @@ Store.prototype._updateCacheForWay2List = async function (list) {
     return;
   }
 
-  let cache_key = this._genCacheKey("get", {});
+  let cache_key = this._genCacheKey('get', {});
   await this.setCache(cache_key, list);
 };
 
@@ -1769,7 +1769,7 @@ Store.prototype._addListByWay = async function (list, way) {
   // 方式2：写后更新缓存
   if (way === 2 && this._cache && result && result.result) {
     // 清除列表缓存，下次读取时会自动更新
-    let cache_key = this._genCacheKey("get", {});
+    let cache_key = this._genCacheKey('get', {});
     await this.delCache(cache_key);
   }
 
@@ -1786,7 +1786,7 @@ Store.prototype._initDrive = async function () {
     return;
   }
 
-  this._drive = new Drive(this.config);
+  this._drive = new Sql(this.config);
   this._drive.sql = this._sql;
   this._drive.cache = this._cache;
 };