mm_dbs 0.0.0-stage → 1.0.1

package/lib/db.js

@@ -0,0 +1,2280 @@
+const fs = require('fs');
+const path = require('path');
+const Item = require('mm_mod').Base;
+const { string, array, object, file } = require('mm_helper');
+
+/** 关键词搜索默认SQL模板（用户表关联查询） */
+const KEYWORD_DEFAULT =
+  "`user_id` in (SELECT `user_id` FROM `user_account` WHERE `nickname` LIKE '%{0}%' OR `phone` LIKE '%{0}%' OR `wallet_address` LIKE '%{0}%')";
+
+/** 关键词搜索默认提示 */
+const KEYWORD_DEFAULT_TIP = '昵称、手机号、钱包地址';
+
+/**
+ * 对LIKE查询中的关键词进行转义, 防止通配符注入和性能攻击
+ * @param {string} keyword 原始关键词
+ * @returns {string} 转义后的安全关键词
+ */
+var escapeLikeKeyword = function (keyword) {
+  if (typeof keyword !== 'string') {
+    return '';
+  }
+  return keyword
+    .replace(/\\/g, '\\\\')
+    .replace(/%/g, '\\%')
+    .replace(/_/g, '\\_');
+};
+
+/**
+ * db数据库开发驱动类
+ * @augments {Item}
+ * @class
+ */
+class Db extends Item {
+  static config = {
+    // 库表名称（唯一标识）
+    name: '',
+    // 标题（中文名）
+    title: '',
+    // 表名
+    table: '',
+    // 主键，用于实体模型
+    key: '',
+    // 字段
+    fields: [/* */],
+    index: [],
+    // 主程序文件 - 默认为空
+    main: '',
+    // 驱动目录（方案B：手动配置，替代目录扫描）
+    dir: '',
+    // 用户ID字段名（替代原全局字典中的 user_id 配置）
+    user_id: 'user_id',
+    // 事件接口管理器获取函数（可选注入，替代原全局 admin 事件查找）
+    get_event_api: null,
+  };
+
+  /**
+   * 构造函数
+   * @param {object} config 配置参数
+   * @param {object} parent 父对象（管理器实例）
+   * @class
+   */
+  constructor(config, parent) {
+    super({ ...Db.config, ...config });
+
+    // 父级管理器引用（用于配置回退与插件查找）
+    this.parent = parent || null;
+
+    // 当前配置文件路径
+    this.config_file = '';
+
+    // 当前驱动目录
+    this._dir = '';
+
+    // 事件接口缺失告警去重标记
+    this._event_api_warned = false;
+
+    // 初始化查询字段配置（原由旧基类 setConfig 触发）
+    this._preset();
+  }
+}
+
+/**
+ * 重置配置参数
+ */
+Db.prototype._preset = function () {
+  this.query_string = [
+    'name',
+    'title',
+    'keywords',
+    'tag',
+    'description',
+    'content',
+  ];
+
+  // 是否设置数值类型为可查询
+  this.query_number = ['state', 'uin'];
+
+  // 是否设置数值类型为关键词可查
+  this.query_keyword = ['name', 'title', 'keywords', 'tag', 'description'];
+
+  // 是否设置以下字段为get查列表SQL时不可见
+  this.get_not = ['password', 'salt', 'content'];
+
+  // 是否设置以下字段为getObj查对象SQL时不可见
+  this.get_obj_not = ['password', 'salt', 'display'];
+
+  // 是否设置默认该表仅用户可访问
+  this.query_default_table = ['user'];
+};
+
+/**
+ * 解析字段类型
+ * @param {string} type 字段类型
+ * @returns {object} 解析结果
+ */
+Db.prototype._parseFieldType = function (type) {
+  var tp = string.left(type, '(', true);
+  var len = string.between(type, '(', ')');
+  var max = 0;
+  var decimal = 0;
+  if (len) {
+    max = Number(string.left(len, ',', true));
+    var d = string.right(len, ',');
+    if (d) {
+      decimal = Number(d);
+    }
+  }
+  return { tp, max, decimal };
+};
+
+/**
+ * 解析字段备注
+ * @param {string} note 字段备注
+ * @param {string} tp 字段类型
+ * @param {number} max_length 最大长度
+ * @returns {object} 解析结果
+ */
+Db.prototype._parseFieldNote = function (note, tp, max_length) {
+  var proc_note = note.replace('：', ':').replace('（', '(').replace('）', ')');
+  var title = string.left(proc_note, ':', true).trim();
+  var desc = string.right(proc_note, ':');
+  var description = '';
+  var map = '';
+  var min = 0;
+  var max = 0;
+  var local_max_length = max_length;
+
+  if (desc) {
+    var range = string.between(desc, '[', ']');
+    if (range) {
+      var min_str = string.left(range, ',', true);
+      if (min_str) {
+        min = Number(min_str);
+      }
+      var max_str = string.right(range, ',');
+      if (max_str) {
+        var n = Number(max_str);
+        if (tp === 'varchar') {
+          if (n < local_max_length) {
+            local_max_length = n;
+          }
+        } else {
+          max = n;
+        }
+      }
+    }
+    map = string.between(desc, '(', ')');
+    description = string.right(desc, ']', true).replace(`(${map})`, '').trim();
+  }
+  let min_length = 0;
+  if (min > 0) {
+    min_length = min;
+  }
+  return {
+    title,
+    description,
+    map,
+    min,
+    max,
+    min_length,
+    max_length: local_max_length,
+  };
+};
+
+/**
+ * 计算字段最大值
+ * @param {string} tp 字段类型
+ * @param {number} max 当前最大值
+ * @param {number} max_length 最大长度
+ * @returns {number} 计算后的最大值
+ */
+Db.prototype._calcMaxValue = function (tp, max, max_length) {
+  var local_max = max;
+  if (local_max === 0) {
+    switch (tp) {
+      case 'tinyint':
+        local_max = 1;
+        break;
+      case 'smallint':
+        local_max = 32767;
+        break;
+      case 'mediumint':
+        local_max = 8388607;
+        break;
+      case 'int':
+        local_max = 2147483647;
+        break;
+      case 'bigint':
+        local_max = 0;
+        break;
+      default:
+        break;
+    }
+    if (max_length) {
+      var num = Math.pow(10, max_length) - 1;
+      if (local_max > num) {
+        local_max = num;
+      }
+    }
+  }
+  return local_max;
+};
+
+/**
+ * 处理字段默认值
+ * @param {string} tp 字段类型
+ * @param {boolean} not_null 是否非空
+ * @param {*} default_val 默认值
+ * @returns {*} 处理后的默认值
+ */
+Db.prototype._handleDefaultValue = function (tp, not_null, default_val) {
+  if (not_null && !default_val) {
+    if (tp === 'varchar' || tp === 'text') {
+      return '';
+    } else if (tp === 'datetime' || tp === 'timestamp') {
+      return 'CURRENT_TIMESTAMP';
+    } else {
+      return '0';
+    }
+  }
+  return default_val;
+};
+
+/**
+ * 创建字段模型对象
+ * @param {string} name 字段名
+ * @param {string} title 字段标题
+ * @param {string} description 字段描述
+ * @param {string} tp 字段类型
+ * @param {boolean} pk 是否主键
+ * @param {boolean} auto 是否自动
+ * @param {boolean} not_null 是否非空
+ * @param {number} min_length 最小长度
+ * @param {number} max_length 最大长度
+ * @param {number} min 最小值
+ * @param {number} max 最大值
+ * @param {number} decimal 小数位
+ * @param {*} default_val 默认值
+ * @param {object} map 转换编排
+ * @returns {object} 字段模型对象
+ * @private
+ */
+Db.prototype._createFieldModel = function (
+  name,
+  title,
+  description,
+  tp,
+  pk,
+  auto,
+  not_null,
+  min_length,
+  max_length,
+  min,
+  max,
+  decimal,
+  default_val,
+  map,
+) {
+  return {
+    // 字段名
+    name: name,
+    // 字段标题
+    title: title,
+    // 字段描述
+    description: description,
+    // 字段类型 smallint短整数、mediumint中长整数、int整数、float浮点数、double双精度、tinyint二进制(0和1的布尔)、text文本、varchar字符串、datetime日期时间、date日期、time时间、timestamp时间戳
+    type: tp,
+    // 是否主键
+    key: pk,
+    // 自动
+    auto: auto,
+    // 是否含符号
+    symbol: tp === 'float' || tp === 'decimal',
+    // 是否填充零，用于数字类型
+    fill_zero: false,
+    // 非空
+    not_null: not_null,
+    // 最小长度
+    min_length: min_length,
+    // 最大长度
+    max_length: max_length,
+    // 最小值
+    min: min,
+    // 最大值
+    max: max,
+    // 小数位
+    decimal: decimal,
+    // 默认值
+    default: default_val,
+    // 转换编排
+    map: map,
+  };
+};
+
+/**
+ * 创建字段模型
+ * @param {object} fields 字段对象
+ * @param {string} fields.name 字段名称
+ * @param {object} fields.default 默认值
+ * @param {object} fields.notnull 是否非空
+ * @param {object} fields.type 字段类型
+ * @param {object} fields.pk 是否主键
+ * @param {object} fields.auto 是否自动增长
+ * @param {object} fields.note 字段备注
+ * @returns {object} 返回字段模型
+ */
+Db.prototype.model = function (fields) {
+  var { name, notnull, type, pk, note, auto } = fields;
+
+  var { tp, max: max_length, decimal } = this._parseFieldType(type);
+  var {
+    title,
+    description,
+    map,
+    min,
+    max: parsedMax,
+    min_length,
+    max_length: parsedMaxLength,
+  } = this._parseFieldNote(note, tp, max_length);
+
+  var max = this._calcMaxValue(tp, parsedMax, parsedMaxLength);
+
+  if (name.indexOf('_id') !== -1 || name == 'id') {
+    min = 0;
+  }
+
+  var not_null = notnull | pk | (tp !== 'varchar' && tp !== 'text');
+
+  var config = this.config;
+  if (pk && !config.key) {
+    config.key = name;
+  }
+
+  var default_value = this._handleDefaultValue(tp, not_null, fields.default);
+
+  return this._createFieldModel(
+    name,
+    title,
+    description,
+    tp,
+    pk,
+    auto,
+    not_null,
+    min_length,
+    parsedMaxLength,
+    min,
+    max,
+    decimal,
+    default_value,
+    map,
+  );
+};
+
+/**
+ * 创建索引字段模型
+ * @param {object} o 索引对象
+ * @property {string} o.Key_name 索引名称
+ * @property {string} o.Non_unique 是否唯一索引
+ * @property {string} o.Column_name 索引字段
+ * @property {string} o.Manager_comment 索引备注
+ * @returns {object} 返回索引模型
+ */
+Db.prototype.newIndexModel = function (o) {
+  return {
+    name: o.Key_name,
+    type: o.Non_unique ? 'unique' : 'index',
+    fields: o.Column_name.replace(/`/g, '').split(','),
+    comment: o.Manager_comment,
+  };
+};
+
+/**
+ * 从数据库更新索引配置
+ * @param {object} db 数据库管理器
+ * @returns {Array} 索引列表
+ */
+Db.prototype._updateFile = async function (db) {
+  var sql = 'SHOW INDEX FROM `' + this.config.table + '`';
+  var rows = await db.run(sql);
+  var dict = {};
+  for (var i = 0; i < rows.length; i++) {
+    var o = rows[i];
+    if (o.Key_name !== 'PRIMARY') {
+      if (!dict[o.Key_name]) {
+        dict[o.Key_name] = {
+          columnName: [],
+        };
+      }
+      dict[o.Key_name].Column_name.push(o.Column_name);
+    }
+  }
+  var list = [];
+  for (var k in dict) {
+    var m = this.newIndexModel(dict[k]);
+    list.push(m);
+  }
+
+  return list;
+};
+
+/**
+ * 从数据库更新配置
+ * @param {object} db 数据库管理器
+ * @param {boolean} cover 是否覆盖文件
+ */
+Db.prototype.updateFile = async function (db, cover) {
+  var cg = this.config;
+  var list = [];
+
+  // 查询表注释并修改
+  var db_name = db.database().replace(/[^a-zA-Z0-9_]/g, '');
+  var sql =
+    "SELECT TABLE_NAME, TABLE_COMMENT FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = '" +
+    db_name +
+    "' && TABLE_NAME = '" +
+    cg.table +
+    "';";
+
+  var lt = await db.run(sql);
+  if (lt && lt.length > 0) {
+    var commit = lt[0].TABLE_COMMENT;
+    var arr = commit.replace('：', ':').split(':');
+    cg.title = arr[0];
+    if (arr.length > 1) {
+      cg.description = arr[1];
+    }
+  }
+
+  // 设置表名
+  db.table = cg.table + '';
+
+  // 获取所有字段
+  var fields = await db.fields();
+  for (var i = 0; i < fields.length; i++) {
+    var field = this.model(fields[i]);
+    list.push(field);
+  }
+  cg.fields = list;
+  cg.index = await this._updateFile(db);
+  if (!cg.name) {
+    cg.name = cg.table;
+  }
+  await this.updateApp(cover);
+};
+
+/**
+ * 更新索引
+ * @param {object} db 数据库管理器
+ */
+Db.prototype._updateDb = async function (db) {
+  var cg = this.config;
+  let index = cg.index || [];
+  // 更新索引
+  if (index) {
+    var len = index.length;
+    for (var i = 0; i < len; i++) {
+      var o = index[i];
+      var sql_start = '';
+      if (o.type === 'unique') {
+        sql_start = 'CREATE UNIQUE INDEX `';
+      } else {
+        sql_start = 'CREATE INDEX `';
+      }
+      await db.exec(
+        sql_start + o.name + '` ON `' + cg.table + '` (' + o.fields + ');',
+      );
+    }
+  }
+};
+
+/**
+ * 初始化数据表
+ * @param {object} db 数据库管理器
+ * @param {object} cg 配置对象
+ * @param {Array} list 字段列表
+ * @returns {Array} 字段列表
+ */
+Db.prototype._initTable = async function (db, cg, list) {
+  var fields = await db.fields();
+  if (fields.length === 0) {
+    var k = cg.key;
+    var len = list.length;
+    for (var i = 0; i < len; i++) {
+      var o = list[i];
+      if (k === o.name) {
+        await db.addTable(
+          cg.table,
+          o.name,
+          o.type,
+          o.auto,
+          cg.title + '：' + cg.description,
+        );
+        fields.push({
+          name: o.name,
+        });
+        break;
+      }
+    }
+  } else {
+    var commit = cg.title + '：' + cg.description;
+    var sql = "alter table `{0}` comment '{1}';"
+      .replace('{0}', cg.table)
+      .replace('{1}', commit);
+    await db.exec(sql);
+  }
+  return fields;
+};
+
+/**
+ * 删除配置中没有的字段
+ * @param {object} db 数据库管理器
+ * @param {Array} fields 数据库字段列表
+ * @param {Array} list 配置字段列表
+ */
+Db.prototype._deleteUnusedFields = async function (db, fields, list) {
+  for (var i = 0; i < fields.length; i++) {
+    var o = fields[i];
+    var obj = array.getObj(list, {
+      name: o.name,
+    });
+
+    if (!obj) {
+      await db.fieldDel(o.name);
+    }
+  }
+};
+
+/**
+ * 生成字段SQL
+ * @param {object} o 字段对象
+ * @returns {string} 字段SQL
+ */
+Db.prototype._generateFieldSql = function (o) {
+  var type = this._getTypeSql(o);
+  var notnull = this._getNotNullSql(o);
+  var value = this._getValueSql(o);
+  var note = this._getNoteSql(o);
+  return this._buildFieldSql(o.name, type, notnull, value, note);
+};
+
+/**
+ * 获取类型SQL
+ * @param {object} o 字段对象
+ * @returns {string} 类型SQL
+ * @private
+ */
+Db.prototype._getTypeSql = function (o) {
+  var type = o.type;
+  var max_len = o.max_length || 0;
+
+  if (max_len > 0) {
+    // decimal仅对浮点类型有效(int/smallint/bigint等使用decimal=0时不追加)
+    var is_float_type =
+      o.type.indexOf('float') !== -1 ||
+      o.type.indexOf('double') !== -1 ||
+      o.type.indexOf('decimal') !== -1;
+    if (is_float_type && o.decimal !== undefined && o.decimal !== null) {
+      type += '(' + max_len + ',' + o.decimal + ')';
+    } else {
+      type += '(' + max_len + ')';
+    }
+  }
+
+  // 类型未包含unsigned且为非字符/日期类型时追加UNSIGNED
+  if (
+    !o.symbol &&
+    type.indexOf('unsigned') === -1 &&
+    o.type !== 'varchar' &&
+    o.type !== 'longtext' &&
+    o.type !== 'text' &&
+    o.type !== 'date' &&
+    o.type !== 'time' &&
+    o.type !== 'datetime' &&
+    o.type !== 'timestamp'
+  ) {
+    type += ' UNSIGNED';
+  }
+
+  return type;
+};
+
+/**
+ * 获取NOT NULL SQL
+ * @param {object} o 字段对象
+ * @returns {string} NOT NULL SQL
+ * @private
+ */
+Db.prototype._getNotNullSql = function (o) {
+  var notnull = '';
+
+  if (this._isNotNullRequired(o)) {
+    notnull = 'NOT NULL';
+  }
+
+  if (this._isAutoInc(o)) {
+    notnull += ' AUTO_INCREMENT';
+  }
+
+  return notnull;
+};
+
+/**
+ * 检查是否需要NOT NULL
+ * @param {object} o 字段对象
+ * @returns {boolean} 是否需要NOT NULL
+ * @private
+ */
+Db.prototype._isNotNullRequired = function (o) {
+  return (
+    o.not_null || this._isDateTimeType(o.type) || this._isNumericType(o.type)
+  );
+};
+
+/**
+ * 检查是否为日期时间类型
+ * @param {string} type 类型
+ * @returns {boolean} 是否为日期时间类型
+ * @private
+ */
+Db.prototype._isDateTimeType = function (type) {
+  return (
+    type === 'date' ||
+    type === 'time' ||
+    type === 'datetime' ||
+    type === 'timestamp'
+  );
+};
+
+/**
+ * 检查是否为数字类型
+ * @param {string} type 类型
+ * @returns {boolean} 是否为数字类型
+ * @private
+ */
+Db.prototype._isNumericType = function (type) {
+  return (
+    type !== 'varchar' &&
+    type !== 'longtext' &&
+    type !== 'text' &&
+    !this._isDateTimeType(type)
+  );
+};
+
+/**
+ * 检查是否需要AUTO_INCREMENT
+ * @param {object} o 字段对象
+ * @returns {boolean} 是否需要AUTO_INCREMENT
+ * @private
+ */
+Db.prototype._isAutoInc = function (o) {
+  return !!o.auto && !this._isDateTimeType(o.type);
+};
+
+/**
+ * 获取默认值SQL
+ * @param {object} o 字段对象
+ * @returns {string} 默认值SQL
+ * @private
+ */
+Db.prototype._getValueSql = function (o) {
+  if (this._isAutoTime(o)) {
+    return 'DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP';
+  }
+
+  if (this._isAutoInc(o)) {
+    return '';
+  }
+
+  if (o.default === null) {
+    // NOT NULL 列不允许 DEFAULT NULL（MySQL 语法错误），此时省略默认值
+    return this._isNotNullRequired(o) ? '' : 'DEFAULT NULL';
+  }
+
+  if (o.default !== undefined) {
+    return this._getDefaultValueSql(o);
+  }
+
+  return this._getDefaultEmptySql(o);
+};
+
+/**
+ * 检查是否为自动时间
+ * @param {object} o 字段对象
+ * @returns {boolean} 是否为自动时间
+ * @private
+ */
+Db.prototype._isAutoTime = function (o) {
+  return !!o.auto && this._isDateTimeType(o.type);
+};
+
+/**
+ * 获取默认值SQL
+ * @param {object} o 字段对象
+ * @returns {string} 默认值SQL
+ * @private
+ */
+Db.prototype._getDefaultValueSql = function (o) {
+  if (this._isCurrentDefault(o)) {
+    return 'DEFAULT ' + o.default;
+  } else if (this._isQuotableType(o.type)) {
+    return "DEFAULT '" + o.default + "'";
+  } else {
+    return 'DEFAULT ' + o.default;
+  }
+};
+
+/**
+ * 检查是否为当前时间默认值
+ * @param {object} o 字段对象
+ * @returns {boolean} 是否为当前时间默认值
+ * @private
+ */
+Db.prototype._isCurrentDefault = function (o) {
+  return (
+    this._isDateTimeType(o.type) &&
+    o.default &&
+    o.default.indexOf('CURR') !== -1
+  );
+};
+
+/**
+ * 检查默认值是否需要引号包裹（字符类型与日期时间类型）
+ * @param {string} type 类型
+ * @returns {boolean} 需要引号返回true，否则返回false
+ * @private
+ */
+Db.prototype._isQuotableType = function (type) {
+  return (
+    type === 'varchar' ||
+    type === 'longtext' ||
+    type === 'text' ||
+    type === 'date' ||
+    type === 'time' ||
+    type === 'datetime' ||
+    type === 'timestamp'
+  );
+};
+
+/**
+ * 获取空默认值SQL
+ * @param {object} o 字段对象
+ * @returns {string} 空默认值SQL
+ * @private
+ */
+Db.prototype._getDefaultEmptySql = function (o) {
+  if (this._isStringType(o.type)) {
+    return "DEFAULT ''";
+  } else {
+    return 'DEFAULT 0';
+  }
+};
+
+/**
+ * 获取注释SQL
+ * @param {object} o 字段对象
+ * @returns {string} 注释SQL
+ * @private
+ */
+Db.prototype._getNoteSql = function (o) {
+  var note = (o.title || '') + '：';
+
+  if (o.type === 'varchar' || o.type === 'text' || o.type === 'longtext') {
+    if (o.max_length) {
+      note += '[' + (o.min_length || '0') + ',' + o.max_length + ']';
+    } else if (o.min_length) {
+      note += '[' + o.min_length + ']';
+    }
+  } else {
+    if (o.max) {
+      note += '[' + (o.min || '0') + ',' + o.max + ']';
+    } else if (o.min) {
+      note += '[' + o.min + ']';
+    }
+  }
+
+  note += o.description || '';
+  if (o.map) {
+    note += '(' + o.map + ')';
+  }
+
+  return note;
+};
+
+/**
+ * 构建字段SQL
+ * @param {string} name 字段名
+ * @param {string} type 类型
+ * @param {string} notnull NOT NULL
+ * @param {string} value 默认值
+ * @param {string} note 注释
+ * @returns {string} 字段SQL
+ * @private
+ */
+Db.prototype._buildFieldSql = function (name, type, notnull, value, note) {
+  var sql = "`{1}` {2} {3} {4} COMMENT '{5}'";
+  return sql
+    .replace('{1}', name)
+    .replace('{2}', type)
+    .replace('{3}', notnull)
+    .replace('{4}', value)
+    .replace('{5}', note);
+};
+
+/**
+ * 添加或修改字段
+ * @param {object} db 数据库管理器
+ * @param {string} table 表名
+ * @param {object} o 字段对象
+ * @param {Array} fields 数据库字段列表
+ */
+Db.prototype._addOrUpdateField = async function (db, table, o, fields) {
+  var arr = fields.filter((f) => {
+    return f.name === o.name;
+  });
+  var sql = this._generateFieldSql(o);
+
+  if (arr.length === 0) {
+    // 如果没有则添加
+    await db.exec('alter table `{0}` add '.replace('{0}', table) + sql);
+  } else {
+    // 如果有则修改
+    await db.exec(
+      'alter table `{0}` change `{1}` '
+        .replace('{0}', table)
+        .replace('{1}', o.name) + sql,
+    );
+  }
+};
+
+/**
+ * 通过配置更新数据库
+ * @param {object} db 数据库管理器
+ * @returns {string} 更新成功返回空，否则返回错误提示
+ */
+Db.prototype.updateDb = async function (db) {
+  var cg = this.config;
+  var table = cg.table + '';
+  var list = cg.fields;
+  db.table = table;
+  var fields = await this._initTable(db, cg, list);
+
+  if (fields.length > 0) {
+    // 删除配置中没有的字段
+    await this._deleteUnusedFields(db, fields, list);
+
+    // 添加或修改配置
+    var len = list.length;
+    for (var i = 0; i < len; i++) {
+      var o = list[i];
+      await this._addOrUpdateField(db, table, o, fields);
+    }
+  } else {
+    return '数据表更新失败';
+  }
+};
+
+/**
+ * 确定目录结构
+ * @param {object} cg 配置对象
+ * @returns {object} 目录信息
+ * @private
+ */
+Db.prototype._deteDir = function (cg) {
+  var arr = cg.table.split('_');
+  var scope = arr[0];
+  var p = file.fullname('./app/');
+  var dir = file.fullname('./' + scope, p);
+  var dir_api = file.fullname('./plugin/server', dir);
+  var db_dir = file.fullname('./db', dir_api);
+  var config_file = file.fullname(
+    './' + cg.table.replace(scope + '_', '') + '.db.json',
+    db_dir,
+  );
+
+  return {
+    scope,
+    dir,
+    dir_api,
+    db_dir,
+    config_file,
+  };
+};
+
+/**
+ * 确保目录存在
+ * @param {string} dir 目录路径
+ * @private
+ */
+Db.prototype._ensureDir = function (dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir);
+  }
+};
+
+/**
+ * 保存当前配置到配置文件（替代旧基类 save）
+ * @returns {void}
+ */
+Db.prototype.save = function () {
+  if (!this.config_file) {
+    return;
+  }
+  try {
+    var file = this.config_file;
+    if (file.hasFile(file)) {
+      var data = file.loadJson(file);
+      if (Array.isArray(data)) {
+        // 数组格式配置：查找并更新现有配置项，不存在则追加
+        var index = data.findIndex((item) => item.name === this.config.name);
+        if (index !== -1) {
+          data[index] = this.config;
+        } else {
+          data.push(this.config);
+        }
+        file.saveText(file, JSON.stringify(data, null, 2));
+        return;
+      }
+    }
+    // 单对象格式配置，直接保存
+    file.saveText(file, JSON.stringify(this.config, null, 2));
+  } catch (err) {
+    this.log('error', '保存配置失败', err);
+  }
+};
+
+/**
+ * 获取当前驱动目录（替代旧基类 getDir）
+ * @returns {string} 目录路径
+ */
+Db.prototype.getDir = function () {
+  if (this._dir) {
+    return this._dir;
+  }
+  if (this.config_file) {
+    return path.dirname(this.config_file);
+  }
+  return '';
+};
+
+/**
+ * 获取事件接口管理器（方案B：可选注入，替代原全局 admin 事件查找）
+ * @returns {object|null} 事件接口管理器实例，未配置返回null
+ * @private
+ */
+Db.prototype._getEventApi = function () {
+  var getter = this.config.get_event_api;
+  if (typeof getter !== 'function' && this.parent) {
+    getter = this.parent.config.get_event_api;
+  }
+  if (typeof getter === 'function') {
+    return getter();
+  }
+  if (!this._event_api_warned) {
+    this._event_api_warned = true;
+    this.log('warn', '未配置 get_event_api，API目录判断使用默认路径');
+  }
+  return null;
+};
+
+/**
+ * 处理配置文件
+ * @param {string} f 文件路径
+ * @param {boolean} cover 是否覆盖文件
+ * @private
+ */
+Db.prototype._handleConfigFile = function (f, cover) {
+  if (!file.hasFile(f)) {
+    this.save();
+  } else if (cover) {
+    var jobj = file.loadJson(f);
+    var o = { ...this.config };
+    if (!o.title) {
+      delete o.title;
+    }
+    if (!o.description) {
+      delete o.description;
+    }
+    object.push(jobj, o, true);
+    file.saveText(f, JSON.stringify(jobj, null, 2));
+  }
+};
+
+/**
+ * 更新应用，根据表生成目录结构和文件
+ * @param {boolean} cover 是否覆盖文件
+ */
+Db.prototype.updateApp = async function (cover) {
+  var cg = this.config;
+  var f;
+  var dir_api;
+
+  if (!this.config_file) {
+    var dirs = this._deteDir(cg);
+    this._ensureDir(dirs.dir);
+    this._ensureDir(dirs.dir + '/plugin');
+    this._ensureDir(dirs.dir_api);
+    this._ensureDir(dirs.db_dir);
+    this._dir = dirs.db_dir;
+    this.config_file = dirs.config_file;
+    f = dirs.config_file;
+    dir_api = dirs.dir_api;
+  } else {
+    if (this.config_file.endsWith('.db.json')) {
+      f = this.config_file;
+    } else {
+      f = this.config_file + '.db.json';
+    }
+  }
+
+  if (f) {
+    file.addDir(f);
+    if (!dir_api) {
+      dir_api = path.dirname(path.dirname(f));
+    }
+    // 处理db配置文件，生成xxx.db.json文件
+    this._handleConfigFile(f, cover);
+    // 更新API及相关配置文件
+    this.updateApi(dir_api, cover);
+  }
+};
+
+/**
+ * 确保API目录存在
+ * @param {string} dir 目录路径
+ * @private
+ */
+Db.prototype._ensureApiDir = function (dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir);
+  }
+};
+
+/**
+ * 确定API目录路径
+ * @param {string} dir 基础目录
+ * @param {string} app 应用名称
+ * @param {string} type 类型 (client 或 manage)
+ * @param {string} name 目录名称
+ * @returns {string} 完整目录路径
+ * @private
+ */
+Db.prototype._getApiDir = function (dir, app, type, name) {
+  var l = path.sep;
+  var event_api = this._getEventApi();
+  var o =
+    event_api && typeof event_api.get === 'function'
+      ? event_api.get(app + '_' + type)
+      : undefined;
+  var api_dir;
+
+  if (o) {
+    api_dir = dir + l + 'api_' + app + '_' + type;
+  } else {
+    api_dir = dir + l + 'api_' + type;
+  }
+
+  this._ensureApiDir(api_dir);
+  api_dir += '/' + name;
+  this._ensureApiDir(api_dir);
+
+  return api_dir;
+};
+
+/**
+ * 更新API及相关配置文件
+ * @param {string} dir API存放目录
+ * @param {boolean} cover 是否覆盖文件
+ */
+Db.prototype.updateApi = async function (dir, cover) {
+  var cg = this.config;
+  var arr = cg.table.split('_');
+
+  var name = 'root';
+  if (arr.length > 1) {
+    name = string.trim(cg.table.replace(arr[0], ''), '_');
+  }
+  var app = arr[0];
+
+  var client = this._getApiDir(dir, app, 'client', name);
+  var manage = this._getApiDir(dir, app, 'manage', name);
+
+  await this.newSql(client, manage, cover);
+  await this.newParam(client, manage, cover);
+  this.newApi(client, manage, cover);
+};
+
+/**
+ * 新建event配置文件和文件
+ * @param {string} dir 保存的路径
+ * @param {string} path 检索路径
+ * @param {string} scope 接口域
+ */
+Db.prototype.newEvent = async function (dir, path, scope) {
+  var f = dir + '/main.js';
+  if (!file.hasFile(f)) {
+    var code = file.loadText(__dirname + '/event_script.js');
+    code = string.replaceAll(string.replaceAll(code, '{0}', path), '{1}', scope);
+    file.saveText(f, code);
+  }
+};
+
+/**
+ * 处理带逗号的列表映射
+ * @param {Array} list 列表
+ * @returns {Array} 处理后的列表
+ * @private
+ */
+Db.prototype._handleCommaList = function (list) {
+  return list.map((o) => {
+    var arr = o.split(',');
+    var value = arr[0];
+    if (arr.length > 0) {
+      return {
+        name: arr[1],
+        value: value,
+      };
+    } else {
+      return {
+        name: value,
+        value,
+      };
+    }
+  });
+};
+
+/**
+ * 处理数字列表映射
+ * @param {Array} list 列表
+ * @param {string} map 映射字符串
+ * @returns {Array} 处理后的列表
+ * @private
+ */
+Db.prototype._handleNumberList = function (list, map) {
+  if (map.indexOf('0') !== 0) {
+    list.unshift('');
+  }
+  return list.map((value) => {
+    return value.replace(/[0-9]+/, '');
+  });
+};
+
+/**
+ * 处理简单列表映射
+ * @param {Array} list 列表
+ * @returns {Array} 处理后的列表
+ * @private
+ */
+Db.prototype._handleSimpleList = function (list) {
+  return list.map((value) => {
+    return {
+      name: value,
+      value,
+    };
+  });
+};
+
+/**
+ * 处理点分隔的映射
+ * @param {object} obj 字段对象
+ * @param {string} map 映射字符串
+ * @returns {object} 处理后的格式对象
+ * @private
+ */
+Db.prototype._handleDotMap = function (obj, map) {
+  var arr = map.split('.');
+  var format = {
+    table: arr[0],
+    name: arr[1],
+  };
+  if (arr.length > 2) {
+    format.id = arr[2];
+  } else {
+    format.id = obj.name;
+  }
+  return format;
+};
+
+/**
+ * 处理简单映射
+ * @param {object} obj 字段对象
+ * @param {string} map 映射字符串
+ * @returns {object} 处理后的格式对象
+ * @private
+ */
+Db.prototype._handleSimpleMap = function (obj, map) {
+  return {
+    table: map,
+    id: obj.name,
+    name: 'name',
+  };
+};
+
+/**
+ * 获取格式
+ * @param {object} obj 字段对象
+ * @returns {object} 返回格式
+ */
+Db.prototype.getFormat = async function (obj) {
+  var map = obj.map;
+  var format = {
+    key: obj.name,
+    title: obj.title.replace('ID', '').replace('id', ''),
+  };
+
+  if (map.indexOf('|') !== -1) {
+    var list = map.split('|');
+    if (map.indexOf(',') !== -1) {
+      format.list = this._handleCommaList(list);
+    } else if (/^[0-9]+/.test(map)) {
+      format.list = this._handleNumberList(list, map);
+    } else {
+      format.list = this._handleSimpleList(list);
+    }
+  } else {
+    if (map.indexOf('.') !== -1) {
+      Object.assign(format, this._handleDotMap(obj, map));
+    } else {
+      Object.assign(format, this._handleSimpleMap(obj, map));
+    }
+  }
+
+  return format;
+};
+
+/**
+ * 处理字段选择
+ * @param {string} field_name 字段名
+ * @param {string} field_type 字段类型
+ * @returns {object} 处理结果
+ * @private
+ */
+Db.prototype._procFieldSel = function (field_name, field_type) {
+  var res = {
+    field: '',
+    field_obj: '',
+  };
+
+  if (this.isCan(field_name, this.get_not, field_type)) {
+    res.field += ',`' + field_name + '`';
+  }
+  if (this.isCan(field_name, this.get_obj_not)) {
+    res.field_obj += ',`' + field_name + '`';
+  }
+  return res;
+};
+
+/**
+ * 处理字符串类型字段
+ * @param {object} query 查询对象
+ * @param {string} field_name 字段名
+ * @param {string} keyword 关键词
+ * @returns {string} 更新后的关键词
+ * @private
+ */
+Db.prototype._procStringQuery = function (query, field_name, keyword) {
+  var new_keyword = keyword;
+  query[field_name] = '`' + field_name + "` like '%{0}%'";
+  if (this.isSet(field_name, this.query_keyword)) {
+    new_keyword += ' || `' + field_name + "` like '%{0}%'";
+  }
+  return new_keyword;
+};
+
+/**
+ * 处理日期时间类型字段
+ * @param {object} query 查询对象
+ * @param {string} field_name 字段名
+ * @private
+ */
+Db.prototype._procDateTimeQuery = function (query, field_name) {
+  query[field_name + '_min'] = '`' + field_name + "` >= '{0}'";
+  query[field_name + '_max'] = '`' + field_name + "` <= '{0}'";
+};
+
+/**
+ * 处理数字类型字段
+ * @param {object} query 查询对象
+ * @param {object} update_obj 更新对象
+ * @param {string} field_name 字段名
+ * @param {string} uid 用户ID
+ * @param {boolean} query_default_user 是否默认用户查询
+ * @param {string} orderby 排序
+ * @returns {object} 处理结果
+ * @private
+ */
+Db.prototype._procNumberQuery = function (
+  query,
+  update_obj,
+  field_name,
+  uid,
+  query_default_user,
+  orderby,
+) {
+  var res = {
+    orderby: orderby,
+    update: { ...update_obj },
+  };
+
+  if (!field_name.endsWith('id')) {
+    query[field_name + '_min'] = '`' + field_name + '` >= {0}';
+    query[field_name + '_max'] = '`' + field_name + '` <= {0}';
+    res.update[field_name + '_add'] =
+      '`' + field_name + '` = `' + field_name + '` + {0}';
+
+    if (
+      field_name === 'sort' ||
+      field_name === 'display' ||
+      field_name === 'orderby'
+    ) {
+      res.orderby = '`' + field_name + '` asc';
+    }
+  } else if (field_name === uid && query_default_user) {
+    res.query_default = '`' + field_name + '` = {' + uid + '}';
+  } else if (field_name === 'available' || field_name === 'show') {
+    res.query_default = '`' + field_name + '` = 1';
+  }
+
+  return res;
+};
+
+/**
+ * 处理字段类型
+ * @param {string} type 字段类型
+ * @param {string} field_name 字段名
+ * @param {object} query 查询对象
+ * @param {object} update_obj 更新对象
+ * @param {string} uid 用户ID
+ * @param {boolean} query_default_user 是否默认用户查询
+ * @param {string} orderby 排序
+ * @param {string} keyword 关键词
+ * @returns {object} 处理结果
+ * @private
+ */
+Db.prototype._procFieldType = function (
+  type,
+  field_name,
+  query,
+  update_obj,
+  uid,
+  query_default_user,
+  orderby,
+  keyword,
+) {
+  var result = {
+    keyword: keyword,
+    orderby: orderby,
+    update_obj: update_obj,
+    query_default: {},
+  };
+
+  if (type === 'varchar' || type === 'text' || type === 'longtext') {
+    result.keyword = this._procStringQuery(query, field_name, keyword);
+  } else if (
+    type === 'date' ||
+    type === 'time' ||
+    type === 'datetime' ||
+    type === 'timestamp'
+  ) {
+    this._procDateTimeQuery(query, field_name);
+  } else if (type !== 'tinyint') {
+    var num_res = this._procNumberQuery(
+      query,
+      update_obj,
+      field_name,
+      uid,
+      query_default_user,
+      orderby,
+    );
+    result.orderby = num_res.orderby;
+    result.update_obj = num_res.update;
+    if (num_res.query_default) {
+      result.query_default[field_name] = num_res.query_default;
+    }
+  }
+
+  return result;
+};
+
+/**
+ * 处理单个字段
+ * @param {object} o 字段对象
+ * @param {object} query 查询对象
+ * @param {object} update_obj 更新对象
+ * @param {string} uid 用户ID
+ * @param {boolean} query_default_user 是否默认用户查询
+ * @param {string} orderby 排序
+ * @param {string} keyword 关键词
+ * @returns {object} 处理结果
+ * @private
+ */
+Db.prototype._procSingleField = async function (
+  o,
+  query,
+  update_obj,
+  uid,
+  query_default_user,
+  orderby,
+  keyword,
+) {
+  var { type, name } = o;
+  var result = {
+    field: '*',
+    field_obj: '*',
+    keyword: keyword,
+    orderby: orderby,
+    update_obj: update_obj,
+    query_default: {},
+    format: [],
+  };
+
+  var field_sel = this._procFieldSel(name, type);
+  result.field = field_sel.field;
+  result.field_obj = field_sel.field_obj;
+
+  var type_info = this._procFieldType(
+    type,
+    name,
+    query,
+    update_obj,
+    uid,
+    query_default_user,
+    orderby,
+    keyword,
+  );
+  result.keyword = type_info.keyword;
+  result.orderby = type_info.orderby;
+  result.update_obj = type_info.update_obj;
+  result.query_default = type_info.query_default;
+
+  if (o.map) {
+    var fmt = await this.getFormat(o);
+    if (fmt) {
+      result.format.push(fmt);
+    }
+  }
+
+  return result;
+};
+
+/**
+ * 处理字段和查询条件
+ * @param {Array} fields 字段列表
+ * @param {string} table 表名
+ * @returns {object} 处理结果
+ * @private
+ */
+Db.prototype._procFields = async function (fields, table) {
+  var query = {};
+  var update_obj = {};
+  var field = '';
+  var field_obj = '';
+  var query_default = {};
+  var format = [];
+  var orderby = '';
+  var uid = this.config.user_id;
+  var keyword = '';
+  var query_default_user = this.isSet(table, this.query_default_table);
+
+  for (var i = 0; i < fields.length; i++) {
+    var field_info = await this._procSingleField(
+      fields[i],
+      query,
+      update_obj,
+      uid,
+      query_default_user,
+      orderby,
+      keyword,
+    );
+
+    field += field_info.field;
+    field_obj += field_info.field_obj;
+    keyword = field_info.keyword;
+    orderby = field_info.orderby;
+    update_obj = field_info.update_obj;
+
+    // 合并查询默认值
+    for (var key in field_info.query_default) {
+      query_default[key] = field_info.query_default[key];
+    }
+
+    // 合并格式
+    format = format.concat(field_info.format);
+  }
+
+  return {
+    query,
+    update: update_obj,
+    field: string.trim(field, ','),
+    field_obj: string.trim(field_obj, ','),
+    query_default,
+    format,
+    orderby,
+    keyword,
+  };
+};
+
+/**
+ * 处理关键字搜索
+ * @param {string} keyword 关键字
+ * @param {string} table 表名
+ * @returns {object} 处理后的查询对象
+ * @private
+ */
+Db.prototype._procKeyword = function (keyword, table) {
+  var safe_keyword = escapeLikeKeyword(keyword);
+  var new_keyword = safe_keyword;
+  if (table.indexOf('user_') !== -1) {
+    new_keyword += ' || ' + KEYWORD_DEFAULT;
+  }
+
+  var query = {};
+  if (new_keyword) {
+    query['keyword'] = '(' + new_keyword.replace(' || ', '') + ')';
+  }
+
+  return query;
+};
+
+/**
+ * 创建基础模型
+ * @param {object} cg 配置对象
+ * @param {object} processed 处理结果
+ * @param {object} keyword_query 关键字查询
+ * @returns {object} 基础模型
+ * @private
+ */
+Db.prototype._createSqlConfig = function (cg, processed, keyword_query) {
+  return {
+    name: cg.table,
+    title: cg.title,
+    table: cg.table,
+    key: cg.key,
+    orderby_default: '`' + cg.key + '` desc',
+    field_obj: processed.field_obj,
+    field_default: processed.field,
+    method: 'get get_obj avg sum count',
+    query: { ...processed.query, ...keyword_query },
+    query_default: processed.query_default,
+    update: processed.update,
+    format: processed.format,
+  };
+};
+
+/**
+ * 保存客户端配置
+ * @param {string} client 客户端配置保存路径
+ * @param {object} base_model 基础模型
+ * @param {boolean} cover 是否覆盖文件
+ * @param {string} orderby 排序
+ * @param {string} uid 用户ID
+ * @param {string} table 表名
+ * @private
+ */
+Db.prototype._saveClientConfig = function (
+  client,
+  base_model,
+  cover,
+  orderby,
+  uid,
+  table,
+) {
+  var oj = { ...base_model };
+  if (orderby) {
+    oj.orderby_default = orderby;
+  }
+  if (
+    oj.orderby_default &&
+    oj.query_default[uid] &&
+    table.indexOf('user_') !== -1
+  ) {
+    oj.filter = {
+      table: 'table',
+      page: 'page',
+      size: 'size',
+      method: 'method',
+      orderby: 'orderby',
+      field: 'field',
+      count_ret: 'count_ret',
+    };
+    oj.filter[uid] = uid;
+  }
+  this.saveFile(client + '/sql.json', oj, cover);
+};
+
+/**
+ * 保存管理端配置
+ * @param {string} manage 管理端配置保存路径
+ * @param {object} base_model 基础模型
+ * @param {boolean} cover 是否覆盖文件
+ * @private
+ */
+Db.prototype._saveManageConfig = function (manage, base_model, cover) {
+  var m = { ...base_model };
+  delete m.method;
+  m.field_hide = [];
+  m.name += 2;
+  m.field_obj = (m.field_obj || '*')
+    .replace(',`time_create`', '')
+    .replace(',`time_update`', '')
+    .replace(',`create_time`', '')
+    .replace(',`update_time`', '');
+  delete m.query_default;
+  this.saveFile(manage + '/sql.json', m, cover);
+};
+
+/**
+ * 新建sql配置文件
+ * @param {string} client 客户端配置保存路径
+ * @param {string} manage 管理端配置保存路径
+ * @param {boolean} cover 是否覆盖文件
+ */
+Db.prototype.newSql = async function (client, manage, cover) {
+  var cg = this.config;
+  var uid = this.config.user_id;
+
+  var processed = await this._procFields(cg.fields, cg.table);
+  var keyword_query = this._procKeyword(processed.keyword, cg.table);
+  var base_model = this._createSqlConfig(cg, processed, keyword_query);
+
+  if (client) {
+    this._saveClientConfig(
+      client,
+      base_model,
+      cover,
+      processed.orderby,
+      uid,
+      cg.table,
+    );
+  }
+
+  if (manage) {
+    this._saveManageConfig(manage, base_model, cover);
+  }
+};
+
+/**
+ * 保存sql配置
+ * @param {string} file 文件名
+ * @param {object} model 配置模型
+ * @param {boolean} cover 是否覆盖文件
+ */
+Db.prototype.saveFile = function (file, model, cover) {
+  if (!file.hasFile(file)) {
+    file.saveText(file, JSON.stringify(model, null, 2));
+  } else if (cover) {
+    var jobj = file.loadJson(file);
+    for (var k in model) {
+      var val = model[k];
+      if (!val) {
+        model[k] = jobj[k];
+      }
+    }
+    object.push(jobj, model, true);
+    file.saveText(file, JSON.stringify(jobj, null, 2));
+  }
+};
+
+/**
+ * 新建param配置文件
+ * @param {string} client 客户端配置保存路径
+ * @param {string} manage 管理端配置保存路径
+ * @param {boolean} cover 是否覆盖文件
+ */
+Db.prototype.newParam = async function (client, manage, cover) {
+  var cg = this.config;
+  var lt = cg.fields;
+  var cm = this._initParamConfig(cg);
+  var keyword = '';
+
+  for (var i = 0; i < lt.length; i++) {
+    var o = lt[i];
+    var p = o.type;
+    var n = o.name;
+    var m = this._createParamModel(o, p, n);
+
+    if (this._isStringType(p)) {
+      keyword = this._processStringField(cm, m, o, n, keyword);
+    } else if (this._isDateTimeType(p)) {
+      this._processDateTimeField(cm, m, o, n);
+    } else {
+      this._processNumberField(cm, m, o, n, cg);
+    }
+  }
+
+  this._addKeywordConfig(cm, keyword, cg);
+  this._saveParamFiles(cm, client, manage, cover);
+};
+
+/**
+ * 初始化参数配置对象
+ * @param {object} cg 配置对象
+ * @returns {object} 参数配置对象
+ * @private
+ */
+Db.prototype._initParamConfig = function (cg) {
+  return {
+    name: cg.table,
+    title: cg.title,
+    add: {
+      body: [],
+      body_required: [],
+    },
+    del: {
+      query: [],
+      query_required: [],
+    },
+    set: {
+      query: [],
+      query_required: [],
+      body: [],
+      body_required: [],
+      body_not: [],
+    },
+    get: {
+      query: [],
+      query_required: [],
+    },
+    get_obj: {
+      query_required: [],
+    },
+    list: [],
+  };
+};
+
+/**
+ * 创建参数模型
+ * @param {object} field 字段对象
+ * @param {string} type 字段类型
+ * @param {string} name 字段名
+ * @returns {object} 参数模型对象
+ * @private
+ */
+Db.prototype._createParamModel = function (field, type, name) {
+  return {
+    name: name,
+    title: field.title,
+    description: field.description + (field.map ? '(' + field.map + ')' : ''),
+    key: field.pk,
+    type: '',
+    dataType: type,
+  };
+};
+
+/**
+ * 检查是否为字符串类型
+ * @param {string} type 字段类型
+ * @returns {boolean} 是否为字符串类型
+ * @private
+ */
+Db.prototype._isStringType = function (type) {
+  return type === 'varchar' || type === 'text' || type === 'longtext';
+};
+
+/**
+ * 处理字符串类型字段
+ * @param {object} cm 参数配置对象
+ * @param {object} m 模型对象
+ * @param {object} o 字段对象
+ * @param {string} n 字段名
+ * @param {string} keyword 关键词
+ * @returns {string} 更新后的关键词
+ * @private
+ */
+Db.prototype._processStringField = function (cm, m, o, n, keyword) {
+  var new_keyword = keyword;
+  m.type = 'string';
+  m.default = o.default;
+  m.string = {};
+
+  this._addStringRange(m, o);
+  this._addStringFormat(m, n);
+
+  if (o.not_null) {
+    m.string.not_empty = !!o.not_null;
+    cm.add.body_required.push(n);
+  } else {
+    cm.add.body.push(n);
+  }
+
+  if (this.isSet(n, this.query_string)) {
+    cm.get.query.push(n);
+    cm.set.query.push(n);
+    new_keyword += '、' + o.title + '(' + n + ')';
+  }
+
+  cm.set.body.push(n);
+  cm.list.push(m);
+  return new_keyword;
+};
+
+/**
+ * 添加字符串范围验证
+ * @param {object} m 模型对象
+ * @param {object} o 字段对象
+ * @private
+ */
+Db.prototype._addStringRange = function (m, o) {
+  var range = o.min_length && o.max_length ? [o.min_length, o.max_length] : [];
+  if (range.length > 0) {
+    m.string.range = range;
+  } else if (o.min_length) {
+    m.string.min = o.min_length;
+  } else if (o.max_length) {
+    m.string.max = o.max_length;
+  }
+};
+
+/**
+ * 检查字段名是否包含指定关键词
+ * @param {string} field_name 字段名
+ * @param {string} keyword 关键词
+ * @returns {boolean} 是否包含
+ * @private
+ */
+Db.prototype._hasKeyword = function (field_name, keyword) {
+  return string.has(field_name, keyword);
+};
+
+/**
+ * 检查字段名是否等于指定值
+ * @param {string} field_name 字段名
+ * @param {Array} values 值数组
+ * @returns {boolean} 是否等于
+ * @private
+ */
+Db.prototype._isEqual = function (field_name, values) {
+  return values.includes(field_name);
+};
+
+/**
+ * 添加字符串格式验证
+ * @param {object} m 模型对象
+ * @param {string} n 字段名
+ * @private
+ */
+Db.prototype._addStringFormat = function (m, n) {
+  if (this._hasKeyword(n, 'phone') || this._isEqual(n, ['tel'])) {
+    m.string.format = 'phone';
+  } else if (
+    this._hasKeyword(n, 'url') ||
+    this._isEqual(n, ['src', 'source'])
+  ) {
+    m.string.format = 'url';
+  } else if (this._hasKeyword(n, 'date')) {
+    m.string.format = 'date';
+  } else if (this._isEqual(n, ['num', 'number', 'count'])) {
+    m.string.format = 'digits';
+  } else if (this._isEqual(n, ['money', 'coin'])) {
+    m.string.format = 'number';
+  } else if (this._hasKeyword(n, 'email')) {
+    m.string.format = 'email';
+  }
+};
+
+/**
+ * 处理日期时间类型字段
+ * @param {object} cm 参数配置对象
+ * @param {object} m 模型对象
+ * @param {object} o 字段对象
+ * @param {string} n 字段名
+ * @private
+ */
+Db.prototype._processDateTimeField = function (cm, m, o, n) {
+  var format = o.type === 'timestamp' ? 'datetime' : o.type;
+  m.type = 'string';
+  m.default = '';
+  m.string = {
+    not_empty: true,
+    format: format,
+  };
+
+  cm.list.push(m);
+  this._addDateTimeRange(cm, m, n);
+
+  if (n.indexOf('create') !== -1 && n.indexOf('update') !== -1) {
+    cm.add.body.push(n);
+    cm.set.body.push(n);
+  }
+
+  cm.get.query.push(n + '_min');
+  cm.get.query.push(n + '_max');
+};
+
+/**
+ * 添加日期时间范围模型
+ * @param {object} cm 参数配置对象
+ * @param {object} m 模型对象
+ * @param {string} n 字段名
+ * @private
+ */
+Db.prototype._addDateTimeRange = function (cm, m, n) {
+  var m_min = { ...m };
+  m_min.name = n + '_min';
+  m_min.title += '——开始时间';
+  cm.list.push(m_min);
+
+  var m_max = { ...m };
+  m_max.name = n + '_max';
+  m_max.title += '——结束时间';
+  cm.list.push(m_max);
+};
+
+/**
+ * 处理数字类型字段
+ * @param {object} cm 参数配置对象
+ * @param {object} m 模型对象
+ * @param {object} o 字段对象
+ * @param {string} n 字段名
+ * @param {object} cg 配置对象
+ * @private
+ */
+Db.prototype._processNumberField = function (cm, m, o, n, cg) {
+  m.type = 'number';
+  m.default = Number(o.default) + '';
+  m.number = {};
+
+  this._addNumberRange(m, o);
+
+  if (o.name === cg.key) {
+    this._processPrimaryKey(cm, m, n);
+  } else {
+    this._processNonPrimaryKey(cm, m, n);
+  }
+};
+
+/**
+ * 添加数字范围验证
+ * @param {object} m 模型对象
+ * @param {object} o 字段对象
+ * @private
+ */
+Db.prototype._addNumberRange = function (m, o) {
+  var range = o.min && o.max ? [o.min, o.max] : [];
+  if (range.length > 0) {
+    m.number.range = range;
+  } else if (o.min) {
+    m.number.min = o.min;
+  } else if (o.max) {
+    m.number.max = o.max;
+  }
+};
+
+/**
+ * 处理主键字段
+ * @param {object} cm 参数配置对象
+ * @param {object} m 模型对象
+ * @param {string} n 字段名
+ * @private
+ */
+Db.prototype._processPrimaryKey = function (cm, m, n) {
+  cm.del.query_required.push(n);
+  cm.set.query.push(n);
+  cm.get.query.push(n);
+  cm.get_obj.query_required.push(n);
+  cm.list.push(m);
+};
+
+/**
+ * 处理非主键字段
+ * @param {object} cm 参数配置对象
+ * @param {object} m 模型对象
+ * @param {string} n 字段名
+ * @private
+ */
+Db.prototype._processNonPrimaryKey = function (cm, m, n) {
+  cm.add.body.push(n);
+  cm.set.body.push(n);
+  cm.list.push(m);
+
+  if (m.dataType !== 'tinyint') {
+    this._processNonTinyInt(cm, m, n);
+  } else {
+    cm.set.query.push(n);
+    cm.get.query.push(n);
+  }
+};
+
+/**
+ * 处理非tinyint字段
+ * @param {object} cm 参数配置对象
+ * @param {object} m 模型对象
+ * @param {string} n 字段名
+ * @private
+ */
+Db.prototype._processNonTinyInt = function (cm, m, n) {
+  var ne = n;
+  if (!ne.endsWith('id')) {
+    this._addNumberRangeFields(cm, m, n);
+  } else {
+    cm.get.query.push(n);
+    if (this.isSet(n, this.query_number)) {
+      cm.set.query.push(n);
+    }
+  }
+};
+
+/**
+ * 添加数字范围字段
+ * @param {object} cm 参数配置对象
+ * @param {object} m 模型对象
+ * @param {string} n 字段名
+ * @private
+ */
+Db.prototype._addNumberRangeFields = function (cm, m, n) {
+  cm.get.query.push(n + '_min');
+  cm.get.query.push(n + '_max');
+  cm.set.query.push(n + '_min');
+  cm.set.query.push(n + '_max');
+  cm.set.body.push(n + '_add');
+
+  var m_min = { ...m };
+  m_min.name = n + '_min';
+  m_min.title += '——最小值';
+  cm.list.push(m_min);
+
+  var m_max = { ...m };
+  m_max.name = n + '_max';
+  m_max.title += '——最大值';
+  cm.list.push(m_max);
+};
+
+/**
+ * 添加关键词配置
+ * @param {object} cm 参数配置对象
+ * @param {string} keyword 关键词
+ * @param {object} cg 配置对象
+ * @private
+ */
+Db.prototype._addKeywordConfig = function (cm, keyword, cg) {
+  if (keyword) {
+    cm.get.query.push('keyword');
+    cm.set.query.push('keyword');
+    var new_keyword = keyword;
+    if (cg.table.indexOf('user_') !== -1) {
+      new_keyword += '、' + KEYWORD_DEFAULT_TIP;
+    }
+    var m_k = {
+      name: 'keyword',
+      title: '关键词',
+      description: '用于搜索' + new_keyword.replace('、', ''),
+      type: 'string',
+      string: {},
+    };
+    cm.list.push(m_k);
+  }
+};
+
+/**
+ * 保存参数配置文件
+ * @param {object} cm 参数配置对象
+ * @param {string} client 客户端配置保存路径
+ * @param {string} manage 管理端配置保存路径
+ * @param {boolean} cover 是否覆盖文件
+ * @private
+ */
+Db.prototype._saveParamFiles = function (cm, client, manage, cover) {
+  if (client) {
+    this.saveFile(client + '/param.json', cm, cover);
+  }
+  if (manage) {
+    var manage_cm = { ...cm };
+    delete manage_cm.method;
+    manage_cm.name += 2;
+    this.saveFile(manage + '/param.json', manage_cm, cover);
+  }
+};
+
+/**
+ * 是否设置
+ * @param {string} name 名称
+ * @param {Array} arr 匹配的对象
+ * @returns {boolean} 是否设置
+ */
+Db.prototype.isSet = function (name, arr) {
+  if (!arr) {
+    return false;
+  }
+  var bl = false;
+  for (var i = 0; i < arr.length; i++) {
+    if (name.indexOf(arr[i]) !== -1) {
+      bl = true;
+      break;
+    }
+  }
+  return bl;
+};
+
+/**
+ * 是否排除
+ * @param {string} name 名称
+ * @param {Array} arr 匹配的对象
+ * @param {string} type 数据类型
+ * @returns {boolean} 是否可以
+ */
+Db.prototype.isCan = function (name, arr, type) {
+  if (type === 'longtext') {
+    return false;
+  }
+  if (!arr) {
+    return true;
+  }
+  var bl = true;
+  for (var i = 0; i < arr.length; i++) {
+    if (name.indexOf(arr[i]) !== -1) {
+      bl = false;
+      break;
+    }
+  }
+  return bl;
+};
+
+/**
+ * 确定API路径
+ * @param {object} cg 配置对象
+ * @returns {string} API路径
+ * @private
+ */
+Db.prototype._deteApiPath = function (cg) {
+  var arr = cg.table.split('_');
+  var p = '/api/';
+  if (arr.length > 1) {
+    p += cg.table.replace('_', '/');
+  } else {
+    p += arr[0];
+  }
+  return p;
+};
+
+/**
+ * 创建基础API配置
+ * @param {object} cg 配置对象
+ * @param {string} path API路径
+ * @returns {object} API配置
+ * @private
+ */
+Db.prototype._createApiConfig = function (cg, path) {
+  return {
+    name: cg.table,
+    title: cg.title,
+    description: cg.description,
+    path: path,
+    method: 'ALL',
+    cache: 0,
+    client_cache: false,
+    param_path: './param.json',
+    sql_path: './sql.json',
+    check_param: true,
+  };
+};
+
+/**
+ * 检查是否包含用户ID字段
+ * @param {Array} fields 字段列表
+ * @returns {boolean} 是否包含用户ID字段
+ * @private
+ */
+Db.prototype._hasUserIdField = function (fields) {
+  for (var i = 0, item; (item = fields[i++]);) {
+    var name = item.name;
+    if (
+      name === this.config.user_id ||
+      name === 'uid' ||
+      name === 'user_id' ||
+      name === 'userid'
+    ) {
+      return true;
+    }
+  }
+  return false;
+};
+
+/**
+ * 保存客户端API配置
+ * @param {string} client 客户端配置保存路径
+ * @param {object} base_config 基础配置
+ * @param {object} cg 配置对象
+ * @param {boolean} cover 是否覆盖文件
+ * @private
+ */
+Db.prototype._saveClientApiConfig = function (
+  client,
+  base_config,
+  cg,
+  cover,
+) {
+  var o = { ...base_config };
+
+  if (cg.title.indexOf('user') !== -1) {
+    if (this._hasUserIdField(cg.fields)) {
+      o.oauth = {
+        scope: true,
+        sign_in: true,
+        vip: 0,
+        user_group: [],
+      };
+    }
+  }
+  o.method = 'GET';
+  this.saveFile(client + '/api.json', o, cover);
+};
+
+/**
+ * 保存管理端API配置
+ * @param {string} manage 管理端配置保存路径
+ * @param {object} base_config 基础配置
+ * @param {boolean} cover 是否覆盖文件
+ * @private
+ */
+Db.prototype._saveManageApiConfig = function (manage, base_config, cover) {
+  var o = { ...base_config };
+  o.oauth = {
+    scope: true,
+    sign_in: true,
+    gm: 2,
+    user_admin: [],
+  };
+  o.path = o.path.replace('/api/', '/apis/');
+  o.name += '_manage';
+  this.saveFile(manage + '/api.json', o, cover);
+};
+
+/**
+ * 新建api配置文件
+ * @param {string} client 客户端配置保存路径
+ * @param {string} manage 管理端配置保存路径
+ * @param {boolean} cover 是否覆盖文件
+ */
+Db.prototype.newApi = async function (client, manage, cover) {
+  var cg = this.config;
+  var path = this._deteApiPath(cg);
+  var base_config = this._createApiConfig(cg, path);
+
+  if (client) {
+    this._saveClientApiConfig(client, base_config, cg, cover);
+  }
+
+  if (manage) {
+    this._saveManageApiConfig(manage, base_config, cover);
+  }
+};
+
+/**
+ * 获取模型
+ * @param {string} type 模型类型
+ * @returns {object} 返回获取到的模型
+ */
+Db.prototype.getModel = function (type) {
+  let model = { ...this.config };
+  let dir = this.getDir();
+  let l = path.sep;
+  let app_name = string.between(dir, 'app' + l, l);
+  let plugin_name = string.between(dir, 'plugin' + l, l);
+  let name = path.basename(dir);
+  model.app = app_name;
+  model.plugin = plugin_name;
+  model.name = model.name || name;
+  return model;
+};
+
+module.exports = Db;