mm_os/com/db/index.js

MM_OS服务端架构，用于快速构建应用程序，支持网站建设、小程序后台、AI应用、物联网(IOT/AIOT)、游戏服务端等多种场景。

const Manager = require('mm_machine').Manager;
const Drive = require('./drive');

/**
 * 数据库帮助类
 * @augments {Manager}
 * @class
 */
class Db extends Manager {
  /**
   * 配置参数
   * @type {object}
   */
  static config = {
    /**
     * 名称
     * @type {string}
     */
    name: '',
    /**
     * 标题
     * @type {string}
     */
    title: '数据库管理',
    /**
     * 描述
     * @type {string}
     */
    description: '这是数据库管理器',
    /**
     * 检索文件名
     * @type {string}
     */
    filename: 'db.json',
    /**
     * 模板目录
     * @type {string}
     */
    tpl_dir: __dirname,
    /**
     * 基础目录
     * @type {string}
     */
    base_dir: '../common/db'.fullname(__dirname),
    /**
     * 自定义目录，加载项目自定义资源
     * @type {string}
     */
    dir: './app'.fullname(),
    /**
     * 搜索模式 dir按目录搜索 | file按文件名搜索
     * @type {string}
     */
    search_way: 'file',
    /**
     * 是否懒加载
     * @type {boolean}
     */
    lazy_load: true,
    /**
     * 模式
     * 1.生产模式，改变文件不会重新加载
     * 2.热更新模式，改变配置文件会重新加载配置，不重新加载脚本
     * 3.热重载模式，改变配置文件都会加载配置和脚本
     * 4.重载模式，执行完后重新加载脚本，避免变量污染
     * 5.热更新+重载模式，改变配置文件重新加载配置和脚本，执行完后重新加载脚本
     * @type {number}
     */
    mode: 3
  };

  /**
   * 构造函数
   * @param {object} config 配置参数
   * @param {object} parent 父级模块
   */
  constructor(config, parent) {
    super({ ...Db.config, ...config }, parent);
  }
}

/**
 * 数据库驱动类
 * @type {Drive}
 */
Db.prototype.Drive = Drive;

/**
 * 加载配置
 * @param {string} path 加载的路径
 */
Db.prototype.updateConfigAll = async function (path) {
  var ph = path || './app/';
  // 获取所有应用路径
  var search_dir;
  var _this = this;
  if (this.scope && this.scope !== $.val.scope) {
    search_dir = this.type + '_' + this.scope;
    var list_scope = $.dir.getAll(ph, search_dir);
    for (var i = 0, o; o = list_scope[i++];) {
      // 获取所有配置文件
      var list_file = $.file.getAll(o, '*' + _this.type + '.json');
      await _this.loadList(list_file);
    }
  } else {
    // 获取所有配置文件
    var list_file = $.file.getAll(ph, '*' + _this.type + '.json');
    await _this.loadList(list_file);
  }
};


/**
 * 获取驱动项
 * @param {string} table 表
 * @returns {object} 返回驱动项
 */
Db.prototype.getObj = function (table) {
  var obj;
  var mods = this.getMods();
  for (var k in mods) {
    var o = mods[k];
    if (o.config.table === table) {
      obj = o;
      break;
    }
  }
  return obj;
};

/**
 * 通过数据库更新配置
 * @param {object} db 数据库管理器
 * @param {string} name 要更新的配置名
 * @param {string} table 表名关键词, 支持*table后缀匹配、table*前缀匹配、*table*包含匹配
 * @param {boolean} cover 是否覆盖文件
 * @returns {string} 更新成功返回null, 失败返回错误提示
 */
Db.prototype.updateFile = async function (db, name, table, cover = true) {
  if (name) {
    var o = this.getMod(name);
    if (o) {
      await o.call('updateFile', db, cover);
    } else {
      return '该配置不存在';
    }
  } else {
    var list = await db.tables(table);
    var len = list.length;
    if (len > 0) {
      for (var i = 0; i < len; i++) {
        var te = list[i];
        var obj = this.getObj(te);
        if (obj) {
          await obj.call('updateFile', db, cover);
        } else {
          var drive = new this.Drive({
            scope: this.config.name
          });
          drive.config.table = te;
          await drive.call('updateFile', db, cover);
          this.setMod(drive.config.table, drive);
        }
      }
    } else {
      return '没有找到相关的数据表';
    }
  }
  return null;
};

/**
 * 通过配置修改数据库
 * @param {object} db 数据库管理器
 * @param {string} name 要更新的配置名
 * @param {string} table 表名关键词, 支持*table后缀匹配、table*前缀匹配、*table*包含匹配
 * @param {boolean} all 是否更新全部表，true为是，false为否
 * @returns {string} 更新成功返回null, 失败返回错误提示
 */
Db.prototype.updateDb = async function (db, name, table, all) {
  var ret;
  if (name) {
    var o = this.getMod(name);
    if (o) {
      ret = await o.call('updateDb', db);
    } else {
      ret = '该配置不存在';
    }
  } else {
    var mods = this.getMods();
    if (table) {
      for (var k in mods) {
        var o = mods[k];
        if (o.config.table === table) {
          ret = await o.call('updateDb', db);
          break;
        }
      }
    } else if (all) {
      for (var k in mods) {
        var o = mods[k];
        await o.call('updateDb', db);
      }
    }
  }
  return ret;
};

exports.Db = Db;

/**
 * Db数据库池
 */
if (!$.pool.db) {
  $.pool.db = {};
}

/**
 * Db数据库管理器，用于创建缓存
 * @param {string} scope 作用域
 * @param {string} title 标题
 * @returns {object} 返回一个缓存类
 */
function dbAdmin(scope, title) {
  var sc = scope || $.val.scope + '';
  var obj = $.pool.db[sc];
  if (!obj) {
    $.pool.db[sc] = new Db({
      scope: sc,
      title: title
    });
    obj = $.pool.db[sc];
  }
  return obj;
}

/**
 * @module 导出db管理器
 */
if ($.admin) {
  $.admin.db = dbAdmin;
}