mm_api 0.0.0-stage → 1.1.0

package/lib/drive.js

@@ -0,0 +1,985 @@
+const fs = require("fs");
+const path = require("path");
+const Item = require("mm_corejs").Base;
+const { string, date } = require("mm_helper");
+const Oauth = require("./oauth.js"); // 是MM自带的身份验证机制，基于Oauth2.0，可以不使用
+
+/**
+ * 加载可选依赖模块
+ * @param {string} id 模块标识
+ * @returns {object|null} 模块对象，缺失时返回null
+ */
+function loadOptional(id) {
+  try {
+    return require(id);
+  } catch (err) {
+    return null;
+  }
+}
+
+const Param = loadOptional("mm_param/lib/drive.js"); // 是MM自带的参数机制，可以不使用
+const Sql = loadOptional("mm_sql/lib/drive.js"); // 是MM自带的sql机制，可以不使用
+
+/** param 实例缓存（模块级，替代原全局 param 模块列表） */
+const PARAM_CACHE = new Map();
+/** sql 实例缓存（模块级，替代原全局 sql 模块列表） */
+const SQL_CACHE = new Map();
+
+/**
+ * 补全文件路径（替代原全局路径补全能力，支持相对/绝对路径）
+ * @param {string} file 文件路径
+ * @param {string} dir 基准目录
+ * @returns {string} 完整路径
+ */
+function _resolvePath(file, dir) {
+  if (!file) {
+    return process.cwd();
+  }
+  if (path.isAbsolute(file)) {
+    return file;
+  }
+  return path.resolve(dir || process.cwd(), file);
+}
+
+/**
+ * 生成XML节点（_toXml 的内部递归辅助）
+ * @param {string} name 节点名
+ * @param {*} value 节点值
+ * @returns {string} XML片段字符串
+ */
+function _xmlNode(name, value) {
+  if (value && typeof value === "object") {
+    return "<" + name + ">" + _toXml(value) + "</" + name + ">";
+  }
+  var text = value === undefined || value === null ? "" : String(value);
+  return "<" + name + ">" + text + "</" + name + ">";
+}
+
+/**
+ * 对象转XML字符串（替代原全局 toXml 的精简等价实现）
+ * @param {object} source 被转换的对象
+ * @returns {string} xml格式字符串
+ */
+function _toXml(source) {
+  var parts = [];
+  for (var key in source) {
+    var val = source[key];
+    if (Array.isArray(val)) {
+      for (var i = 0; i < val.length; i++) {
+        parts.push(_xmlNode(key, val[i]));
+      }
+    } else {
+      parts.push(_xmlNode(key, val));
+    }
+  }
+  return parts.join("");
+}
+
+/**
+ * 构建错误响应体（替代原全局 ret.error，默认 json-rpc 形态）
+ * @param {number} code 错误码
+ * @param {string} message 错误信息
+ * @returns {object} 形如 { error: { code, message } } 的响应体
+ */
+function _retError(code, message) {
+  return {
+    error: {
+      code,
+      message,
+    },
+  };
+}
+
+/**
+ * 去除 JSON 文本中的注释（支持 // 与整块注释，不处理字符串内部）
+ * @param {string} text 原始文本
+ * @returns {string} 去除注释后的文本
+ */
+function _stripComments(text) {
+  var out = "";
+  var in_string = false;
+  var in_line = false;
+  var in_block = false;
+  var quote = "";
+
+  for (var i = 0; i < text.length; i++) {
+    var char = text[i];
+    var next = text[i + 1];
+
+    if (in_line) {
+      if (char === "\n") {
+        in_line = false;
+        out += char;
+      }
+      continue;
+    }
+    if (in_block) {
+      if (char === "*" && next === "/") {
+        in_block = false;
+        i++;
+      }
+      continue;
+    }
+    if (in_string) {
+      out += char;
+      if (char === "\\") {
+        out += next === undefined ? "" : next;
+        i++;
+        continue;
+      }
+      if (char === quote) {
+        in_string = false;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      in_string = true;
+      quote = char;
+      out += char;
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      in_line = true;
+      i++;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      in_block = true;
+      i++;
+      continue;
+    }
+    out += char;
+  }
+  return out;
+}
+
+/**
+ * 读取并解析 JSON 配置文件（自动去除注释）
+ * @param {string} file 配置文件绝对路径
+ * @returns {object} 解析后的配置对象
+ * @throws {Error} 文件读取或解析失败时抛出
+ */
+function _readJsonConfig(file) {
+  var text = fs.readFileSync(file, "utf-8");
+  return JSON.parse(_stripComments(text));
+}
+
+/**
+ * Api接口驱动类
+ * @augments {Item}
+ * @class
+ */
+class Drive extends Item {
+  static config = {
+    // 应用名称 例如：demo_app
+    app: "server",
+    // 插件名称 例如：demo_plugin
+    plugin: "sys",
+    // 名称
+    name: "",
+    // 状态 0未启用，1启用
+    state: 1,
+    // 主脚本文件（方案B：由 add() 手动配置，替代目录扫描）
+    main: "./index.js",
+    // 驱动目录（方案B：手动配置，替代目录扫描）
+    dir: "",
+    // 路径 例如：/demo
+    path: "",
+    // 接口类型，api表示服务端数据类型，web表示网页类型，app表示第三方应用类型
+    type: "api",
+    // 请求方式, POST或GET, 为空或ALL表示都可以
+    method: "ALL",
+    // 缓存时长 (单位：秒) 默认：60秒，建议600秒
+    cache: 0,
+    // 是否用客户端缓存，即 http 304 状态
+    client_cache: false,
+    // param参数验证路径 例如: ./param.json
+    param_path: "",
+    // sql模板路径 例如: ./sql.json
+    sql_path: "",
+    // 是否验证参数
+    check_param: true,
+    // 登录token请求头键名（替代原全局 dict 中的 token 键）
+    token_key: "token",
+    // 会话缓存键前缀（替代原全局 dict 中的 session_id 键）
+    session_key: "mm:uuid",
+    // 缓存实例获取函数（可选注入，未配置则跳过缓存读写）
+    get_cache: null,
+    // oauth身份验证模型, 参考oauth文件
+    oauth: {
+      scope: true,
+      sign_in: false,
+      vip: 0,
+      gm: 0,
+      mc: 0,
+      user_admin: [],
+      user_group: [],
+    },
+  };
+  /**
+   * 构造函数
+   * @param {object} config 配置项
+   * @param {object} parent 父对象（管理器实例）
+   * @class
+   */
+  constructor(config, parent) {
+    super({ ...Drive.config, ...config });
+
+    // 父级管理器引用（用于缓存、插件与默认配置回退）
+    this.parent = parent || null;
+
+    // 脚本加载标记（方案B：替代旧基类 isLoaded 机制）
+    this._loaded = false;
+
+    // 初始化运行时数据结构（原由旧基类加载流程触发）
+    this._preset();
+  }
+}
+
+/**
+ * 预设配置
+ */
+Drive.prototype._preset = function () {
+  this.save_dir = "./static/file/";
+  this.url_path = "/file/";
+
+  // oauth身份验证配置 + 函数
+  this.oauth = null;
+  // param参数配置 + 函数
+  this.param = null;
+  // sql模板配置 + 函数
+  this.sql = null;
+
+  var cg = this.config;
+  this._loadParam(cg.param_path);
+  this._loadSql(cg.sql_path);
+  this._loadOauth();
+};
+
+/**
+ * 获取驱动目录（方案B：来自手动配置的 dir，替代旧基类 getDir）
+ * @returns {string} 驱动目录
+ */
+Drive.prototype.getDir = function () {
+  return this.config.dir || __dirname;
+};
+
+/**
+ * 读取 JSON 配置驱动文件（自动去除注释，失败仅记录日志不抛错）
+ * @param {string} file 配置文件绝对路径
+ * @returns {object|null} 配置对象，文件不存在或解析失败返回 null
+ * @private
+ */
+Drive.prototype._loadJsonConfig = function (file) {
+  if (!fs.existsSync(file)) {
+    this.log("warn", "配置文件不存在", file);
+    return null;
+  }
+  try {
+    return _readJsonConfig(file);
+  } catch (err) {
+    this.log("warn", "配置解析失败", file, err.message);
+    return null;
+  }
+};
+
+/**
+ * 获取缓存实例（方案B：可选注入，驱动配置优先，回退父级管理器配置）
+ * @returns {object|null} 缓存实例；未配置返回 null
+ * @private
+ */
+Drive.prototype._getCache = function () {
+  var fn = this.config.get_cache;
+  if (typeof fn !== "function" && this.parent) {
+    fn = this.parent.config.get_cache;
+  }
+  return typeof fn === "function" ? fn() : null;
+};
+
+/**
+ * 设置参数对象（写入模块级缓存，替代原全局 param 模块列表）
+ * @param {object} param 参数对象
+ */
+Drive.prototype.updateParam = function (param) {
+  PARAM_CACHE.set(param.config_file, param);
+};
+
+/**
+ * 获取现有参数
+ * @param {string} file 文件名
+ * @returns {object} 获取的对象
+ */
+Drive.prototype.getParam = function (file) {
+  return PARAM_CACHE.get(file) || null;
+};
+
+/**
+ * 加载参数配置（方案B：读取 param.json 作为驱动配置，替代旧脚本动态加载）
+ * @param {string} file_path 参数文件路径
+ * @returns {object|null} 参数驱动实例，未配置或加载失败返回 null
+ */
+Drive.prototype._loadParam = function (file_path) {
+  if (!file_path || !Param) {
+    return null;
+  }
+  var p = _resolvePath(file_path, this.getDir());
+  var param = this.getParam(p);
+  if (param) {
+    this.param = param;
+    return param;
+  }
+  var cfg = this._loadJsonConfig(p);
+  if (!cfg) {
+    return null;
+  }
+  cfg.config_file = p;
+  cfg.dir = path.dirname(p);
+  this.param = new Param(cfg, this);
+  this.updateParam(this.param);
+  return this.param;
+};
+
+/**
+ * 设置Sql（写入模块级缓存，替代原全局 sql 模块列表）
+ * @param {object} sql sql对象
+ * @param {string} sql.config_file 文件名
+ * @param {object} sql.sql  sql语句
+ */
+Drive.prototype.updateSql = function (sql) {
+  SQL_CACHE.set(sql.config_file, sql);
+};
+
+/**
+ * 获取现有sql模板
+ * @param {string} file 文件名
+ * @returns {object} 获取的对象
+ */
+Drive.prototype.getSql = function (file) {
+  return SQL_CACHE.get(file) || null;
+};
+
+/**
+ * 加载sql模板配置（方案B：读取 sql.json 作为驱动配置，替代旧脚本动态加载）
+ * @param {string} file_path sql模板文件路径
+ * @returns {object|null} sql驱动实例，未配置或加载失败返回 null
+ */
+Drive.prototype._loadSql = function (file_path) {
+  if (!file_path || !Sql) {
+    return null;
+  }
+  var p = _resolvePath(file_path, this.getDir());
+  var sql = this.getSql(p);
+  if (sql) {
+    this.sql = sql;
+    return sql;
+  }
+  var cfg = this._loadJsonConfig(p);
+  if (!cfg) {
+    return null;
+  }
+  cfg.name = cfg.name || this.config.name;
+  cfg.config_file = p;
+  cfg.dir = path.dirname(p);
+  this.sql = new Sql(cfg, this);
+  this.updateSql(this.sql);
+  return this.sql;
+};
+
+/**
+ * 加载身份验证配置
+ */
+Drive.prototype._loadOauth = function () {
+  var cg = this.config.oauth;
+  if (cg) {
+    this.oauth = new Oauth({
+      dir: this.getDir(),
+      token_key: this.config.token_key,
+      session_key: this.config.session_key,
+      get_cache: () => this._getCache(),
+    });
+    this.oauth.loadObj(cg);
+  }
+};
+
+/**
+ * 获取脚本文件完整路径
+ * @returns {string|null} 脚本文件路径，未配置返回null
+ * @private
+ */
+Drive.prototype._getScriptFile = function () {
+  var main = this.config.main || "";
+  if (!main) {
+    return null;
+  }
+  return _resolvePath(main, this.getDir());
+};
+
+/**
+ * 脚本是否已加载（方案B：替代旧基类 isLoaded 机制）
+ * @returns {boolean} 是否已加载
+ */
+Drive.prototype.isLoaded = function () {
+  return this._loaded;
+};
+
+/**
+ * 加载主脚本文件（方案B：标准 require，替代旧基类 do("load") 与热重载模式）
+ * @returns {object|null} 加载的模块对象
+ */
+Drive.prototype.load = function () {
+  var file = this._getScriptFile();
+  if (!file || !fs.existsSync(file)) {
+    return null;
+  }
+  try {
+    var cs = require(file);
+    this._setMainMethod(cs);
+    return cs;
+  } catch (err) {
+    this.log("error", "加载脚本文件失败", err);
+    return null;
+  }
+};
+
+/**
+ * 将脚本模块成员挂到驱动实例
+ * @param {object} mod 模块对象
+ * @private
+ */
+Drive.prototype._setMainMethod = function (mod) {
+  if (!mod) {
+    return;
+  }
+  var name = this.config.func_name || "main";
+  if (typeof mod[name] === "function") {
+    this.main = mod[name];
+  }
+  for (var key in mod) {
+    var obj = mod[key];
+    if (obj !== undefined && obj !== null) {
+      this[key] = obj;
+    }
+  }
+  this._loaded = true;
+};
+
+/**
+ * 保存文件
+ * @param {object} files 上传的文件
+ * @param {string} files.file 上传的文件对象
+ * @returns {object} 返回文件路径和URL
+ */
+Drive.prototype.saveFile = function (files) {
+  var file;
+  var url;
+  if (files.file) {
+    var f = files.file;
+    // 安全处理文件名: 移除路径穿越字符和特殊字符
+    var name = f.name || f.originalFilename;
+    name = name.replace(/[\\/]|\.\./g, "_");
+    file = _resolvePath("./" + name, this.save_dir);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    // 创建写入流
+    var read_stream = fs.createReadStream(f.filepath);
+
+    try {
+      let write_stream = fs.createWriteStream(file);
+      read_stream.pipe(write_stream);
+
+      read_stream.on("error", (err) => {
+        this.log("error", "读取文件流失败", err);
+        write_stream.destroy();
+      });
+      write_stream.on("error", (err) => {
+        this.log("error", "写入文件流失败", err);
+        read_stream.destroy();
+      });
+
+      url = this.url_path + name;
+    } catch (err) {
+      this.log("error", "保存文件失败", err);
+    }
+  }
+  return {
+    file,
+    url,
+  };
+};
+
+/**
+ * 从数据库获取登录态（方案B：实例私有方法，替代原全局 getState 回调）
+ * @param {object} db 数据管理器
+ * @param {string} token token
+ * @returns {object|null} 登录态与用户信息
+ * @private
+ */
+Drive.prototype._getState = async function (db, token) {
+  var db1 = db.new("user_state", "user_id");
+  var state = await db1.getObj(
+    {
+      token,
+    },
+    null,
+    null,
+    false,
+  );
+  if (!state) {
+    return null;
+  }
+  var now = new Date();
+  if (date.interval(state.time_sign, now, "day") <= 30) {
+    db.table = "user_account";
+    var user = await db.getObj({
+      user_id: state.user_id,
+    });
+    var o = { ...user };
+    o.password_pay = o.password_pay ? "******" : "";
+    o.password = o.password ? "******" : "";
+    delete o.salt;
+    delete o.time_create;
+    return {
+      state,
+      user: o,
+    };
+  } else {
+    return null;
+  }
+};
+
+/**
+ * 获取登录态（原名 getState，因与 mm_corejs 生命周期 getState 冲突而更名）
+ * @param {object} ctx 请求上下文
+ * @param {object} db 数据管理器
+ * @returns {object} 执行结果
+ */
+Drive.prototype.getLoginState = async function (ctx, options) {
+  var o = await this._getUserFromSession(ctx);
+  if (!o) {
+    o = await this._getUserFromToken(ctx, options);
+  }
+  return this._processUserInfo(o);
+};
+
+/**
+ * 从 session 中获取用户信息
+ * @param {object} ctx 请求上下文
+ * @returns {object|null} 用户信息
+ * @private
+ */
+Drive.prototype._getUserFromSession = function (ctx) {
+  var u = ctx.session?.user;
+  if (u) {
+    var o = { ...u };
+    o.token = ctx.session.uuid;
+    return o;
+  }
+  return null;
+};
+
+/**
+ * 从 token 中获取用户信息
+ * @param {object} ctx 请求上下文
+ * @param {object} db 数据管理器
+ * @returns {object|null} 用户信息
+ * @private
+ */
+Drive.prototype._getUserFromToken = async function (ctx, options) {
+  var token = ctx.headers[this.config.token_key];
+  if (!token) {
+    return null;
+  }
+  var cache = this._getCache();
+  if (cache) {
+    var u = await cache.get(this.config.session_key + "_" + token);
+    if (u) {
+      return await this._processUserFromCache(u, ctx, options, token);
+    }
+  }
+  return await this._getUserFromDb(token, ctx, options);
+};
+
+/**
+ * 处理缓存中的用户信息
+ * @param {object|string} u 缓存中的用户信息
+ * @param {object} ctx 请求上下文
+ * @param {object} db 数据管理器
+ * @param {string} token token
+ * @returns {object|null} 用户信息
+ * @private
+ */
+Drive.prototype._processUserFromCache = async function (u, ctx, options, token) {
+  var o;
+  if (typeof u === "string") {
+    o = { ...string.toJson(u) };
+  } else if (Object.keys(u).length > 0) {
+    o = { ...u };
+  }
+  if (!o) {
+    return null;
+  }
+  if (!o.user_id) {
+    return await this._getUserFromDb(token, ctx, options);
+  }
+  o.token = token;
+  return o;
+};
+
+/**
+ * 从数据库中获取用户信息
+ * @param {string} token token
+ * @param {object} ctx 请求上下文
+ * @param {object} db 数据管理器
+ * @returns {object|null} 用户信息
+ * @private
+ */
+Drive.prototype._getUserFromDb = async function (token, ctx, options) {
+  var obj = await this._getState(db, token);
+  if (obj) {
+    var o = { ...obj.user };
+    ctx.session.user = obj.user;
+    o.token = ctx.session.uuid;
+    obj.state.token = o.token;
+    return o;
+  }
+  return null;
+};
+
+/**
+ * 处理用户信息
+ * @param {object|null} o 用户信息
+ * @returns {object|null} 处理后的用户信息
+ * @private
+ */
+Drive.prototype._processUserInfo = function (o) {
+  if (o) {
+    o.password_pay = o.password_pay ? "******" : "";
+    o.password = o.password ? "******" : "";
+    delete o.salt;
+    delete o.time_create;
+  }
+  return o;
+};
+
+/**
+ * 获取登录态
+ * @param {object} ctx 请求上下文
+ * @param {object} db 数据管理器
+ * @returns {object} 执行结果
+ */
+Drive.prototype.before = async function (ctx, options) {
+  if (this.config.oauth && this.config.oauth.sign_in) {
+    db.user = await this.getLoginState(ctx, options);
+  }
+};
+
+/**
+ * 主要函数
+ * @param {object} ctx 请求上下文
+ * @param {object} db 数据管理器
+ * @returns {object} 执行结果
+ */
+Drive.prototype.main = async function (ctx, options) {
+  if (this.sql) {
+    var req = ctx.request;
+    // 获取文件
+    if (req.files) {
+      var fobj = this.saveFile(req.files);
+      req.body.file = fobj.file;
+      req.body.url = fobj.url;
+    }
+    var ret = await this.sql.run(req.query, req.body, db);
+    return ret;
+  } else {
+    return _retError(10000, "接口函数未定义");
+  }
+};
+
+/**
+ * 调用函数
+ * @param {object} ctx  请求上下文
+ * @param {object} db 数据管理器
+ * @returns {object} 执行结果
+ */
+Drive.prototype.run = async function (ctx, options) {
+  try {
+    var body = await this.getCache(ctx);
+    if (!body) {
+      var req = ctx.request;
+      var md = this.config["method"].toLocaleUpperCase();
+      if (md !== req.method && md !== "ALL") {
+        return null;
+      }
+      await this.before(ctx, options);
+      var ret = await this.check(ctx, options);
+      if (!ret) {
+        try {
+          ret = await this.main(ctx, options);
+        } catch (err) {
+          this.log("error", "脚本文件错误", req.path, err);
+          ret = _retError(10000, "脚本文件错误：" + err.toString());
+        }
+      }
+      var res = ctx.response;
+      body = this.body(ret, res, req.type);
+      this.setCache(ctx, body, res.type);
+    }
+  } catch (err) {
+    this.log("error", "接口错误", ctx.path, err);
+  }
+  return body;
+};
+
+/**
+ * 获取缓存
+ * @param {object} ctx 请求上下文
+ * @returns {string} 响应内容
+ */
+Drive.prototype.getCache = async function (ctx) {
+  var cg = this.config;
+  if (cg.cache) {
+    var req = ctx.request;
+    if (cg.client_cache) {
+      var etag = req.headers["if-none-match"];
+      if (etag) {
+        var stamp = Number(etag.replace('"', "").replace('"', ""));
+        var cha = stamp * 1000 - Date.parse(new Date());
+        if (cha > 0) {
+          ctx.response.status = 304;
+          return " ";
+        }
+      }
+    } else {
+      var cache = this._getCache();
+      if (cache) {
+        var data = await cache.get("api_" + req.url);
+        if (data) {
+          var obj = JSON.parse(data);
+          ctx.response.type = obj.type;
+          return obj.body;
+        }
+      }
+    }
+  }
+  return null;
+};
+
+/**
+ * 设置缓存
+ * @param {object} ctx 请求上下文
+ * @param {object} body 正文参数
+ * @param {string} type 响应类型
+ */
+Drive.prototype.setCache = async function (ctx, body, type = null) {
+  var cg = this.config;
+  if (cg.cache && ctx.method === "GET") {
+    if (cg.client_cache) {
+      var age = cg.cache * 60;
+      ctx.set("Cache-Control", "max-age=" + age);
+      ctx.etag = Date.parse(new Date()) / 1000 + age;
+    } else {
+      var cache = this._getCache();
+      if (cache) {
+        var req = ctx.request;
+        var o = {};
+        o.body = body;
+        o.type = ctx.response.type;
+        cache.set("api_" + req.url, JSON.stringify(o), cg.cache * 60);
+      }
+    }
+  }
+};
+
+/**
+ * 调用函数
+ * @param {object} result 设置响应结果
+ * @param {object} res 响应器
+ * @param {string} t 请求类型
+ * @returns {string} 处理后的响应结果
+ */
+Drive.prototype.body = function (result, res, t) {
+  var ret = result;
+  var type = res.type;
+  if (!ret) {
+    return ret;
+  }
+  var tp = typeof ret;
+  if (tp === "object") {
+    type = this._handleObjectType(res, type, t);
+    return this._convertObject(ret, type);
+  } else if (tp === "string") {
+    ret = ret.trim();
+    this._handleStringType(res, type, ret);
+  }
+  return ret;
+};
+
+/**
+ * 处理对象类型
+ * @param {object} res 响应器
+ * @param {string} type 类型
+ * @param {string} t 请求类型
+ * @returns {string} 处理后的类型
+ * @private
+ */
+Drive.prototype._handleObjectType = function (res, type, t) {
+  var new_type = type;
+  if (!new_type) {
+    new_type = t.indexOf("xml") !== -1 ? t : "application/json; charset=utf-8";
+    res.type = new_type;
+  } else {
+    new_type = this._normType(new_type);
+    res.type = new_type;
+  }
+  return new_type;
+};
+
+/**
+ * 标准化类型
+ * @param {string} type 类型
+ * @returns {string} 标准化后的类型
+ * @private
+ */
+Drive.prototype._normType = function (type) {
+  if (type.indexOf("json") !== -1) {
+    return "application/json; charset=utf-8";
+  } else if (type.indexOf("html") !== -1) {
+    return "text/html";
+  } else if (type.indexOf("xml") !== -1) {
+    return "text/xml; charset=utf-8";
+  }
+  return "text/plain; charset=utf-8";
+};
+
+/**
+ * 转换对象
+ * @param {object} obj 对象
+ * @param {string} type 类型
+ * @returns {string} 转换后的字符串
+ * @private
+ */
+Drive.prototype._convertObject = function (obj, type) {
+  return type.indexOf("/xml") !== -1 ? _toXml(obj) : JSON.stringify(obj);
+};
+
+/**
+ * 处理字符串类型
+ * @param {object} res 响应器
+ * @param {string} type 类型
+ * @param {string} str 字符串
+ * @private
+ */
+Drive.prototype._handleStringType = function (res, type, str) {
+  if (!type) {
+    if (
+      (str.startsWith("{") && str.endsWith("}")) ||
+      (str.startsWith("[") && str.endsWith("]"))
+    ) {
+      res.type = "application/json; charset=utf-8";
+    } else if (str.endsWith("</html>")) {
+      res.type = "text/html";
+    } else if (str.startsWith("<?xml")) {
+      res.type = "text/xml; charset=utf-8";
+    } else {
+      res.type = "text/plain; charset=utf-8";
+    }
+  }
+};
+
+/**
+ * 验证参数
+ * @param {object} query url参数
+ * @param {object} body 内容参数
+ * @param {string} method 方法
+ * @returns {object} 验证结果
+ */
+Drive.prototype.checkParam = function (query, body, method) {
+  if (this.param) {
+    var msg = this.param.check(query, body, method);
+    if (msg) {
+      var code;
+      if (msg.indexOf("必须") !== -1 || msg.indexOf("为空") !== -1) {
+        code = 30001;
+      } else {
+        code = 30002;
+      }
+      return _retError(code, msg);
+    }
+  }
+  return null;
+};
+
+/**
+ * 验证参数
+ * @param {object} ctx 内容上下文
+ * @returns {object} 验证结果
+ */
+Drive.prototype.check = async function (ctx) {
+  var error;
+  if (this.config.check_param) {
+    var req = ctx.request;
+    error = this.checkParam(req.query, req.body, req.method);
+  }
+  if (!error) {
+    error = await this.checkOauth(ctx);
+    if (error) {
+      error = {
+        error,
+      };
+    }
+  }
+  return error;
+};
+
+/**
+ * 验证身份
+ * @param {object} ctx 内容上下文
+ * @returns {object} 验证结果
+ */
+Drive.prototype.checkOauth = async function (ctx) {
+  var aouth = this.oauth;
+  if (aouth) {
+    return await aouth.check(ctx);
+  } else {
+    return null;
+  }
+};
+
+/**
+ * 获取插件（方案B：从父级管理器插件注册表查找，替代原全局插件池）
+ * @param {string} app 应用名称
+ * @param {string} name 插件名称
+ * @returns {object} 返回获取到的插件
+ */
+Drive.prototype.plugin = function (app, name) {
+  var l = path.sep;
+  var dir = this.config.dir || "";
+  var app_name = app || string.between(dir, "app" + l, l);
+  var plugin_name = name || string.between(dir, "plugin" + l, l);
+  var plus;
+  var plugins = this.parent?.plugins?.[app_name];
+  if (plugins) {
+    plus = plugins.get(plugin_name);
+  }
+  return plus;
+};
+
+/**
+ * 获取模型
+ * @param {string} type 模型类型
+ * @returns {object} 返回获取到的模型
+ */
+Drive.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;
+  model.path = "/" + app_name + "/" + name;
+  return model;
+};
+
+module.exports = Drive;