mm_os 3.3.1 → 4.0.0

package/com/db/drive.js

@@ -0,0 +1,1999 @@
+const Item = require('mm_machine').Drive;
+const fs = require('fs');
+
+if (!$.dict.user_id) {
+  $.dict.user_id = 'user_id';
+}
+
+var keyword_default =
+  "`user_id` in (SELECT `user_id` FROM `user_account` WHERE `nickname` LIKE '%{0}%' OR `phone` LIKE '%{0}%' OR `wallet_address` LIKE '%{0}%')";
+
+var keyword_default_tip = '昵称、手机号、钱包地址';
+
+/**
+ * db数据库开发驱动类
+ * @augments {Item}
+ * @class 
+ */
+class Drive extends Item {
+  static config = {
+    // 库表名称（唯一标识）
+    'name': 'db',
+    // 标题（中文名）
+    'title': '',
+    // 表名
+    'table': '',
+    // 主键，用于实体模型
+    'key': '',
+    // 字段
+    'fields': [
+      /* */
+    ],
+    'index‌': [],
+    // 主程序文件 - 默认为空
+    'main': ''
+  };
+
+  /**
+   * 构造函数
+   * @param {object} config 配置参数
+   * @param {object} parent 父对象
+   * @class
+   */
+  constructor(config, parent) {
+    super({ ...Drive.config, ...config }, parent);
+  }
+}
+
+/**
+ * 重置配置参数
+ */
+Drive.prototype._reset = 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.getobj_not = ['password', 'salt', 'display'];
+
+  // 是否设置默认该表仅用户可访问
+  this.query_default_table = ['user'];
+}
+
+/**
+ * 解析字段类型
+ * @param {string} type 字段类型
+ * @returns {object} 解析结果
+ */
+Drive.prototype._parseFieldType = function (type) {
+  var tp = type.left('(', true);
+  var len = type.between('(', ')');
+  var max = 0;
+  var decimal = 0;
+  if (len) {
+    max = number(len.left(',', true));
+    var d = len.right(',');
+    if (d) {
+      decimal = number(d);
+    }
+  }
+  return { tp, max, decimal };
+};
+
+/**
+ * 解析字段备注
+ * @param {string} note 字段备注
+ * @param {string} tp 字段类型
+ * @param {number} max_length 最大长度
+ * @returns {object} 解析结果
+ */
+Drive.prototype._parseFieldNote = function (note, tp, max_length) {
+  var proc_note = note.replace('：', ':').replace('（', '(').replace('）', ')');
+  var title = proc_note.left(':', true).trim();
+  var desc = proc_note.right(':');
+  var description = '';
+  var map = '';
+  var min = 0;
+  var max = 0;
+  var local_max_length = max_length;
+
+  if (desc) {
+    description = desc.right(']', true).left('(', true).trim();
+    var range = desc.between('[', ']');
+    if (range) {
+      var min_str = range.left(',', true);
+      if (min_str) {
+        min = number(min_str);
+      }
+      var max_str = range.right(',');
+      if (max_str) {
+        var n = number(max_str);
+        if (tp === 'varchar') {
+          if (n < local_max_length) {
+            local_max_length = n;
+          }
+        } else {
+          max = n;
+        }
+      }
+    }
+    map = desc.between('(', ')');
+  }
+
+  return { title, description, map, min, max, max_length: local_max_length };
+};
+
+/**
+ * 计算字段最大值
+ * @param {string} tp 字段类型
+ * @param {number} max 当前最大值
+ * @param {number} max_length 最大长度
+ * @returns {number} 计算后的最大值
+ */
+Drive.prototype._calculateMaxValue = 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 {*} 处理后的默认值
+ */
+Drive.prototype._handleDefaultValue = function (tp, not_null, default_val) {
+  if (not_null && !default_val) {
+    if (tp === 'varchar' || tp === 'text') {
+      return '';
+    } 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
+ */
+Drive.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} 返回字段模型
+ */
+Drive.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,
+    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} 返回索引模型
+ */
+Drive.prototype.modelmanager = 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} 索引列表
+ */
+Drive.prototype.updateFilemanager = function (db) {
+  var sql = 'SHOW INDEX FROM `' + this.config.table + '`';
+  var rows = 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] = {
+          column_name: []
+        };
+      }
+      dict[o.Key_name].Column_name.push(o.Column_name);
+    }
+  }
+  var list = [];
+  for (var k in dict) {
+    var m = this.modelmanager(dict[k]);
+    list.push(m);
+  }
+
+  return list;
+};
+
+/**
+ * 从数据库更新配置
+ * @param {object} db 数据库管理器
+ * @param {boolean} cover 是否覆盖文件
+ */
+Drive.prototype.updateFile = async function (db, cover) {
+  var cg = this.config;
+  var list = [];
+
+  // 查询表注释并修改
+  var sql = "SELECT TABLE_NAME, TABLE_COMMENT FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = '" + db
+    .database() +
+    "' && 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.updateFilemanager(db);
+  if (!cg.name) {
+    cg.name = cg.table;
+  }
+  await this.updateApp(cover);
+};
+
+/**
+ * 更新索引
+ * @param {object} db 数据库管理器
+ */
+Drive.prototype.updateDbmanager = 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 `' + table + '` (' + o.fields + ');');
+    }
+  }
+};
+
+/**
+ * 初始化数据表
+ * @param {object} db 数据库管理器
+ * @param {object} cg 配置对象
+ * @param {Array} list 字段列表
+ * @returns {Array} 字段列表
+ */
+Drive.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 配置字段列表
+ */
+Drive.prototype._deleteUnusedFields = async function (db, fields, list) {
+  for (var i = 0; i < fields.length; i++) {
+    var o = fields[i];
+    var obj = list.getObj({
+      name: o.name
+    });
+
+    if (!obj) {
+      await db.fieldDel(o.name);
+    }
+  }
+};
+
+/**
+ * 生成字段SQL
+ * @param {object} o 字段对象
+ * @returns {string} 字段SQL
+ */
+Drive.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
+ */
+Drive.prototype._getTypeSql = function (o) {
+  var type;
+  if (o.decimal) {
+    type = o.type + '(' + o.max_length + ',' + o.decimal + ')';
+  } else {
+    type = o.type + '(' + o.max_length + ')';
+  }
+
+  if (!o.symbol && (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
+ */
+Drive.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
+ */
+Drive.prototype._isNotNullRequired = function (o) {
+  return o.not_null || this._isDateTimeType(o.type) || this._isNumericType(o.type);
+};
+
+/**
+ * 检查是否为日期时间类型
+ * @param {string} type 类型
+ * @returns {boolean} 是否为日期时间类型
+ * @private
+ */
+Drive.prototype._isDateTimeType = function (type) {
+  return type === 'date' || type === 'time' || type === 'datetime' || type === 'timestamp';
+};
+
+/**
+ * 检查是否为数字类型
+ * @param {string} type 类型
+ * @returns {boolean} 是否为数字类型
+ * @private
+ */
+Drive.prototype._isNumericType = function (type) {
+  return type !== 'varchar' && type !== 'longtext' && type !== 'text' && !this._isDateTimeType(type);
+};
+
+/**
+ * 检查是否需要AUTO_INCREMENT
+ * @param {object} o 字段对象
+ * @returns {boolean} 是否需要AUTO_INCREMENT
+ * @private
+ */
+Drive.prototype._isAutoInc = function (o) {
+  return o.auto && !this._isDateTimeType(o.type);
+};
+
+/**
+ * 获取默认值SQL
+ * @param {object} o 字段对象
+ * @returns {string} 默认值SQL
+ * @private
+ */
+Drive.prototype._getValueSql = function (o) {
+  if (this._isAutoTime(o)) {
+    return 'DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP';
+  }
+
+  if (o.default === null) {
+    return 'DEFAULT NULL';
+  }
+
+  if (o.default) {
+    return this._getDefaultValueSql(o);
+  }
+
+  return this._getDefaultEmptySql(o);
+};
+
+/**
+ * 检查是否为自动时间
+ * @param {object} o 字段对象
+ * @returns {boolean} 是否为自动时间
+ * @private
+ */
+Drive.prototype._isAutoTime = function (o) {
+  return o.auto && this._isDateTimeType(o.type);
+};
+
+/**
+ * 获取默认值SQL
+ * @param {object} o 字段对象
+ * @returns {string} 默认值SQL
+ * @private
+ */
+Drive.prototype._getDefaultValueSql = function (o) {
+  if (this._isCurrentDefault(o)) {
+    return 'DEFAULT ' + o.default;
+  } else if (this._isStringType(o.type)) {
+    return "DEFAULT '" + o.default + "'";
+  } else {
+    return 'DEFAULT ' + o.default;
+  }
+};
+
+/**
+ * 检查是否为当前时间默认值
+ * @param {object} o 字段对象
+ * @returns {boolean} 是否为当前时间默认值
+ * @private
+ */
+Drive.prototype._isCurrentDefault = function (o) {
+  return this._isDateTimeType(o.type) && o.default.indexOf('CURR') !== -1;
+};
+
+/**
+ * 检查是否为字符串类型
+ * @param {string} type 类型
+ * @returns {boolean} 是否为字符串类型
+ * @private
+ */
+Drive.prototype._isStringType = 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
+ */
+Drive.prototype._getDefaultEmptySql = function (o) {
+  if (this._isStringType(o.type)) {
+    return "DEFAULT ''";
+  } else {
+    return 'DEFAULT 0';
+  }
+};
+
+/**
+ * 获取注释SQL
+ * @param {object} o 字段对象
+ * @returns {string} 注释SQL
+ * @private
+ */
+Drive.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 + ',' + o.max_length + ']';
+    } else if (o.min_length) {
+      note += '[' + o.min_length + ']';
+    }
+  } else {
+    if (o.max) {
+      note += '[' + o.min + ',' + 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
+ */
+Drive.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 数据库字段列表
+ */
+Drive.prototype._addOrUpdateField = async function (db, table, o, fields) {
+  var arr = fields.get({
+    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} 更新成功返回空，否则返回错误提示
+ */
+Drive.prototype.updateDb = async function (db) {
+  var cg = this.config;
+  db.table = cg.table + '';
+  var table = cg.table;
+  var list = cg.fields;
+
+  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
+ */
+Drive.prototype._deteDire = function (cg) {
+  var p = './app/'.fullname();
+  var dir_arr = cg.table.split('_');
+  var scope = dir_arr[0];
+  var dir = p + scope;
+  var dir_api = dir + '/plugin/server';
+  var db_dir = dir_api + '/db';
+  var config_file = db_dir.fullname() + cg.table.replace(scope + '_', '') + '.db.json';
+
+  return {
+    scope,
+    dir,
+    dir_api,
+    db_dir,
+    config_file
+  };
+};
+
+/**
+ * 确保目录存在
+ * @param {string} dir 目录路径
+ * @private
+ */
+Drive.prototype._ensureDir = function (dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir);
+  }
+};
+
+/**
+ * 处理配置文件
+ * @param {string} f 文件路径
+ * @param {boolean} cover 是否覆盖文件
+ * @private
+ */
+Drive.prototype._handleConfigFile = function (f, cover) {
+  if (!f.hasFile()) {
+    this.save();
+  } else if (cover) {
+    var jobj = f.loadJson();
+    var o = { ...this.config };
+    if (!o.title) {
+      delete o.title;
+    }
+    if (!o.description) {
+      delete o.description;
+    }
+    $.push(jobj, o, true);
+    f.saveText(JSON.stringify(jobj, null, 4));
+  }
+};
+
+/**
+ * 更新应用，根据表生成目录结构和文件
+ * @param {boolean} cover 是否覆盖文件
+ */
+Drive.prototype.updateApp = async function (cover) {
+  var cg = this.config;
+  var f;
+  var dir_api;
+
+  if (!this.config_file) {
+    var dirs = this._deteDire(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.fullname();
+    this.config_file = dirs.config_file;
+    f = dirs.config_file;
+    dir_api = dirs.dir_api;
+  } else {
+    f = this.config_file + '.db.json';
+  }
+
+  if (f) {
+    if (!this.dir) {
+      this.dir = f.dirname();
+      if (!fs.existsSync(this.dir)) {
+        fs.mkdirSync(this.dir);
+      }
+    }
+    if (!dir_api) {
+      dir_api = this.dir.dirname();
+    }
+
+    this._handleConfigFile(f, cover);
+    this.updateApi(dir_api, cover);
+  }
+};
+
+/**
+ * 确保API目录存在
+ * @param {string} dir 目录路径
+ * @private
+ */
+Drive.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
+ */
+Drive.prototype._deteApiDir = function (dir, app, type, name) {
+  var l = $.slash;
+  var o = $.pool.api[app + '_' + type];
+  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 是否覆盖文件
+ */
+Drive.prototype.updateApi = async function (dir, cover) {
+  var cg = this.config;
+  var arr = cg.table.split('_');
+
+  var name = 'root';
+  if (arr.length > 1) {
+    name = cg.table.replace(arr[0], '').trim('_');
+  }
+  var app = arr[0];
+
+  var client = this._deteApiDir(dir, app, 'client', name);
+  var manage = this._deteApiDir(dir, app, 'manage', name);
+
+  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 接口域
+ */
+Drive.prototype.newEvent = async function (dir, path, scope) {
+  var f = dir + '/main.js';
+  if (!f.hasFile()) {
+    var code = (__dirname + '/event_script.js').loadText();
+    code = code.replaceAll('{0}', path).replaceAll('{1}', scope);
+    f.saveText(code);
+  }
+};
+
+/**
+ * 处理带逗号的列表映射
+ * @param {Array} list 列表
+ * @returns {Array} 处理后的列表
+ * @private
+ */
+Drive.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
+ */
+Drive.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
+ */
+Drive.prototype._handleSimpleList = function (list) {
+  return list.map((value) => {
+    return {
+      name: value,
+      value
+    };
+  });
+};
+
+/**
+ * 处理点分隔的映射
+ * @param {object} obj 字段对象
+ * @param {string} map 映射字符串
+ * @returns {object} 处理后的格式对象
+ * @private
+ */
+Drive.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
+ */
+Drive.prototype._handleSimpleMap = function (obj, map) {
+  return {
+    table: map,
+    id: obj.name,
+    name: 'name'
+  };
+};
+
+/**
+ * 获取格式
+ * @param {object} obj 字段对象
+ * @returns {object} 返回格式
+ */
+Drive.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
+ */
+Drive.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.getObj_not)) {
+    res.field_obj += ',`' + field_name + '`';
+  }
+
+  return res;
+};
+
+/**
+ * 处理字符串类型字段
+ * @param {object} query 查询对象
+ * @param {string} field_name 字段名
+ * @param {string} keyword 关键词
+ * @returns {string} 更新后的关键词
+ * @private
+ */
+Drive.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
+ */
+Drive.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
+ */
+Drive.prototype._procNumberQuery = function (
+  query, update_obj, field_name, uid, query_default_user, orderby
+) {
+  var res = {
+    orderby: orderby,
+    update: { ...update_obj }
+  };
+
+  if (!field_name.end('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
+ */
+Drive.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} field 字段对象
+ * @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
+ */
+Drive.prototype._procSingleField = async function (
+  field, query, update_obj, uid, query_default_user, orderby, keyword
+) {
+  var o = field;
+  var p = o.type;
+  var n = o.name;
+  var result = {
+    field: '',
+    field_obj: '',
+    keyword: keyword,
+    orderby: orderby,
+    update_obj: update_obj,
+    query_default: {},
+    format: []
+  };
+
+  var field_sel = this._procFieldSel(n, p);
+  result.field = field_sel.field;
+  result.field_obj = field_sel.field_obj;
+
+  var type_info = this._procFieldType(
+    p, n, 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
+ */
+Drive.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 = $.dict.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,
+    field_obj,
+    query_default,
+    format,
+    orderby,
+    keyword
+  };
+};
+
+/**
+ * 处理关键字搜索
+ * @param {string} keyword 关键字
+ * @param {string} table 表名
+ * @returns {object} 处理后的查询对象
+ * @private
+ */
+Drive.prototype._procKeyword = function (keyword, table) {
+  var new_keyword = 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
+ */
+Drive.prototype._createBaseModel = 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.replace(',', ''),
+    field_default: processed.field.replace(',', ''),
+    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 {string} orderby 排序
+ * @param {string} uid 用户ID
+ * @param {string} table 表名
+ * @param {boolean} cover 是否覆盖文件
+ * @private
+ */
+Drive.prototype._saveClientConfig = function (client, base_model, orderby, uid, table, cover) {
+  var oj = { ...base_model };
+  if (orderby) {
+    oj.orderby_default = orderby;
+  }
+  if (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
+ */
+Drive.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 是否覆盖文件
+ */
+Drive.prototype.newSql = async function (client, manage, cover) {
+  var cg = this.config;
+  var uid = $.dict.user_id;
+
+  var processed = await this._procFields(cg.fields, cg.table);
+  var keyword_query = this._procKeyword(processed.keyword, cg.table);
+  var base_model = this._createBaseModel(cg, processed, keyword_query);
+
+  if (client) {
+    this._saveClientConfig(client, base_model, processed.orderby, uid, cg.table, cover);
+  }
+
+  if (manage) {
+    this._saveManageConfig(manage, base_model, cover);
+  }
+};
+
+/**
+ * 保存sql配置
+ * @param {string} file 文件名
+ * @param {object} model 配置模型
+ * @param {boolean} cover 是否覆盖文件
+ */
+Drive.prototype.saveFile = function (file, model, cover) {
+  if (!file.hasFile()) {
+    file.saveText(JSON.stringify(model, null, 4));
+  } else if (cover) {
+    var jobj = file.loadJson();
+    for (var k in model) {
+      var val = model[k];
+      if (!val) {
+        model[k] = jobj[k];
+      }
+    }
+    $.push(jobj, model, true);
+    file.saveText(JSON.stringify(jobj, null, 4));
+  }
+};
+
+/**
+ * 新建param配置文件
+ * @param {string} client 客户端配置保存路径
+ * @param {string} manage 管理端配置保存路径
+ * @param {boolean} cover 是否覆盖文件
+ */
+Drive.prototype.new = 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._createBaseModel(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
+ */
+Drive.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
+ */
+Drive.prototype._createBaseModel = 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
+ */
+Drive.prototype._isStringType = function (type) {
+  return type === 'varchar' || type === 'text' || type === 'longtext';
+};
+
+/**
+ * 检查是否为日期时间类型
+ * @param {string} type 字段类型
+ * @returns {boolean} 是否为日期时间类型
+ * @private
+ */
+Drive.prototype._isDateTimeType = function (type) {
+  return type === 'date' || type === 'time' || type === 'datetime' || type === 'timestamp';
+};
+
+/**
+ * 处理字符串类型字段
+ * @param {object} cm 参数配置对象
+ * @param {object} m 模型对象
+ * @param {object} o 字段对象
+ * @param {string} n 字段名
+ * @param {string} keyword 关键词
+ * @returns {string} 更新后的关键词
+ * @private
+ */
+Drive.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
+ */
+Drive.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
+ */
+Drive.prototype._hasKeyword = function (field_name, keyword) {
+  return field_name.has(keyword);
+};
+
+/**
+ * 检查字段名是否等于指定值
+ * @param {string} field_name 字段名
+ * @param {Array} values 值数组
+ * @returns {boolean} 是否等于
+ * @private
+ */
+Drive.prototype._isEqual = function (field_name, values) {
+  return values.includes(field_name);
+};
+
+/**
+ * 添加字符串格式验证
+ * @param {object} m 模型对象
+ * @param {string} n 字段名
+ * @private
+ */
+Drive.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
+ */
+Drive.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
+ */
+Drive.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
+ */
+Drive.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
+ */
+Drive.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
+ */
+Drive.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
+ */
+Drive.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
+ */
+Drive.prototype._processNonTinyInt = function (cm, m, n) {
+  var ne = n;
+  if (!ne.end('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
+ */
+Drive.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
+ */
+Drive.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
+ */
+Drive.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} 是否设置
+ */
+Drive.prototype.isSet = function (name, arr) {
+  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} 是否可以
+ */
+Drive.prototype.isCan = function (name, arr, type) {
+  if (type === 'longtext') {
+    return false;
+  }
+  var bl = false;
+  for (var i = 0; i < arr.length; i++) {
+    if (name.indexOf(arr[i]) !== -1) {
+      bl = true;
+      break;
+    }
+  }
+  return !bl;
+};
+
+
+/**
+ * 确定API路径
+ * @param {object} cg 配置对象
+ * @returns {string} API路径
+ * @private
+ */
+Drive.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
+ */
+Drive.prototype._createBaseApiConfig = 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
+ */
+Drive.prototype._hasUserIdField = function (fields) {
+  for (var i = 0, item; item = fields[i++];) {
+    var name = item.name;
+    if (name == $.dict.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
+ */
+Drive.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
+ */
+Drive.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 是否覆盖文件
+ */
+Drive.prototype.newApi = async function (client, manage, cover) {
+  var cg = this.config;
+  var path = this._deteApiPath(cg);
+  var base_config = this._createBaseApiConfig(cg, path);
+
+  if (client) {
+    this._saveClientApiConfig(client, base_config, cg, cover);
+  }
+
+  if (manage) {
+    this._saveManageApiConfig(manage, base_config, cover);
+  }
+};
+
+/**
+ * 获取模型
+ * @param {string} type 模型类型
+ * @returns {object} 返回获取到的模型
+ */
+Drive.prototype.getModel = function (type) {
+  let model = { ...this.config };
+  let dir = this._getDir();
+  let l = $.slash;
+  let app_name = dir.between('app' + l, l);
+  let plugin_name = dir.between('plugin' + l, l);
+  let name = dir.basename();
+  model.app = app_name;
+  model.plugin = plugin_name;
+  model.name = model.name || name;
+  return model;
+};
+
+module.exports = Drive;