mm_mysql 2.5.6 → 2.6.0

package/lib/tools/mysql/index.js

@@ -0,0 +1,208 @@
+/**
+ * MySQL管理器
+ * 管理 MySQL 连接和操作（基于 mm_mysql 连接池）
+ * SQL 方法: query/execute/upsert, ORM 方法: add/del/set/get/getObj/count
+ */
+async function main(params, ctx, options) {
+  const { mysqlAdmin } = require('mm_mysql');
+  var action = params.action || '';
+  var table = params.table || '';
+  var sql = params.sql || '';
+  var sql_params = params.params || [];
+  var query = params.query || {};
+  var body = params.body || {};
+  var unique = params.unique || [];
+
+  var opts = this.getOptions();
+
+  var mysql = mysqlAdmin('os', opts);
+  await mysql.open();
+
+  ctx.output = await dispatch(mysql, action, table, sql, sql_params, query, body, unique);
+  return ctx.output;
+}
+
+/**
+ * 分发 action 到对应的处理方法
+ */
+async function dispatch(mysql, action, table, sql, sql_params, query, body, unique) {
+  const SQL_METHODS = ['query', 'run', 'execute', 'exec', 'insert', 'update', 'delete'];
+  const ORM_METHODS = ['add', 'del', 'set', 'get', 'getObj', 'list', 'count'];
+
+  if (SQL_METHODS.indexOf(action) !== -1) {
+    return handleSql(mysql, action, sql, sql_params);
+  }
+  if (ORM_METHODS.indexOf(action) !== -1) {
+    return handleOrm(mysql, action, table, query, body);
+  }
+  if (action === 'upsert') {
+    return handleUpsert(mysql, table, body, unique);
+  }
+  if (action === 'batch') {
+    return handleBatch(mysql, sql_params);
+  }
+  if (action === 'runSql') {
+    return handleRunSql(mysql, sql);
+  }
+  return { error: { code: 'MGR_UNKNOWN_ACTION', message: '不支持的操作: ' + action } };
+}
+
+/**
+ * 处理 SQL 方法: query/run → SELECT, execute/exec → INSERT/UPDATE/DELETE
+ */
+async function handleSql(mysql, action, sql, sql_params) {
+  var is_query = action === 'query' || action === 'run';
+  var result = is_query ? await mysql.run(sql, sql_params) : await mysql.exec(sql, sql_params);
+
+  if (mysql.error) {
+    return _errorResult('MGR_SQL_ERROR', mysql.error.message);
+  }
+  return is_query
+    ? {
+        list: Array.isArray(result) ? result : [],
+        count: Array.isArray(result) ? result.length : 0
+      }
+    : { affected: result || 0 };
+}
+
+/**
+ * 处理 ORM 方法: add/del/set/get/getObj/count
+ */
+async function handleOrm(mysql, action, table, query, body) {
+  var db = mysql.db();
+  db.table = table;
+
+  var result;
+  switch (action) {
+    case 'add':
+      result = await db.add(body);
+      break;
+    case 'del':
+      result = await db.del(query);
+      break;
+    case 'set':
+      result = await db.set(query, body);
+      break;
+    case 'list':
+      result = await db.list(query);
+      break;
+    case 'getObj':
+      result = await db.getObj(query);
+      break;
+    case 'count':
+      result = await db.count(query);
+      break;
+  }
+
+  if (db.error) {
+    return _errorResult('MGR_ORM_ERROR', db.error.message);
+  }
+  return result;
+}
+
+/**
+ * 处理 upsert: INSERT ... ON DUPLICATE KEY UPDATE
+ */
+async function handleUpsert(mysql, table, body, unique) {
+  var upsert_sql = _buildUpsert(table, body, unique);
+  var result = await mysql.exec(upsert_sql.sql, upsert_sql.params);
+
+  if (mysql.error) {
+    return _errorResult('MGR_UPSERT_ERROR', mysql.error.message);
+  }
+  return { affected: 1, id: result || 0 };
+}
+
+/**
+ * 批量执行 SQL 列表（用于建表等初始化操作）
+ * @param {object} mysql 数据库实例
+ * @param {Array} sqls SQL 语句数组
+ * @returns {object} { affected, count }
+ */
+async function handleBatch(mysql, sqls) {
+  if (!Array.isArray(sqls) || sqls.length === 0) {
+    return { error: { code: 'MGR_BATCH_EMPTY', message: 'SQL 列表不能为空' } };
+  }
+  var affected = 0;
+  for (var i = 0; i < sqls.length; i++) {
+    var r = await mysql.exec(sqls[i], []);
+    if (mysql.error) {
+      return _errorResult('MGR_BATCH_ERROR', mysql.error.message + ' [第' + (i + 1) + '条SQL]');
+    }
+    affected += r || 0;
+  }
+  return { affected: affected, count: sqls.length };
+}
+
+/**
+ * 执行多语句 SQL 脚本（支持分号分隔的建表/插入语句）
+ * @param {object} mysql 数据库实例
+ * @param {string} sql SQL 脚本内容
+ * @returns {object} { success, statements, affected_rows }
+ */
+async function handleRunSql(mysql, sql) {
+  if (!sql) {
+    return _errorResult('MGR_SQL_EMPTY', 'SQL 语句不能为空');
+  }
+  var result = await mysql.runSql(sql);
+  if (mysql.error) {
+    return _errorResult('MGR_RUNSQL_ERROR', mysql.error.message);
+  }
+  return {
+    success: result.success,
+    statements: result.statements,
+    affected_rows: result.affected_rows
+  };
+}
+
+/**
+ * 构建错误结果对象
+ */
+function _errorResult(code, message) {
+  return { error: { code: code, message: message } };
+}
+
+/**
+ * 构建 upsert SQL (INSERT ... ON DUPLICATE KEY UPDATE)
+ * @param {string} table 表名
+ * @param {object} body 数据对象 { field: value }
+ * @param {array} unique 唯一约束字段列表（可选）
+ * @returns {object} { sql, params }
+ */
+function _buildUpsert(table, body, unique) {
+  var fields = Object.keys(body);
+  var values = [];
+  var placeholders = [];
+  for (var i = 0; i < fields.length; i++) {
+    values.push(body[fields[i]]);
+    placeholders.push('?');
+  }
+
+  var updates = [];
+  var update_fields =
+    unique.length > 0
+      ? fields.filter(function (f) {
+          return unique.indexOf(f) === -1;
+        })
+      : fields;
+  for (var j = 0; j < update_fields.length; j++) {
+    var f = update_fields[j];
+    updates.push('`' + f + '` = VALUES(`' + f + '`)');
+  }
+
+  var sql_str =
+    'INSERT INTO `' +
+    table +
+    '` (`' +
+    fields.join('`, `') +
+    '`) VALUES (' +
+    placeholders.join(', ') +
+    ')';
+  if (updates.length > 0) {
+    sql_str += ' ON DUPLICATE KEY UPDATE ' + updates.join(', ');
+  }
+
+  return { sql: sql_str, params: values };
+}
+
+module.exports = { main };

package/lib/tools/mysql_rw/index.js

@@ -0,0 +1,228 @@
+/**
+ * MySQL 读写分离管理器
+ * 基于 mm_mysql 的 mysqlAdmin 管理连接池，实现读写分离路由
+ * SQL 方法: query(SELECT→读库) / insert/update/delete(→写库)
+ * ORM 方法: add/set/del(→写库) / getObj/list/count(→读库)
+ * 读库从 replicas 随机选择一台，未配置从库时读写都走主库
+ */
+/**
+ * 判断 SQL 是否为读操作
+ * @param {string} sql SQL 语句
+ * @returns {boolean} 是否为读操作
+ */
+function _isReadOp(sql) {
+  var trimmed = sql.trim().toUpperCase();
+  return (
+    trimmed.startsWith('SELECT') ||
+    trimmed.startsWith('SHOW') ||
+    trimmed.startsWith('DESCRIBE') ||
+    trimmed.startsWith('EXPLAIN')
+  );
+}
+
+/**
+ * 选择读库(随机)
+ * @param {Array} replicas 读库配置列表
+ * @returns {object} 读库配置
+ */
+function _pickReplica(replicas) {
+  if (!replicas || replicas.length === 0) {
+    return null;
+  }
+  var idx = Math.floor(Math.random() * replicas.length);
+  return replicas[idx];
+}
+
+/**
+ * 判断操作路由: 写→master, 读→replica
+ * @param {string} action 操作类型
+ * @param {string} sql SQL 语句
+ * @returns {boolean} 是否为读操作
+ */
+function _isReadAction(action, sql) {
+  var orm_write = ['add', 'set', 'del', 'insert', 'update', 'delete'];
+  var orm_read = ['getObj', 'list', 'count'];
+  if (action === 'runSql') return false;
+  if (orm_write.indexOf(action) !== -1) return false;
+  if (orm_read.indexOf(action) !== -1) return true;
+  if (action === 'query') return true;
+  if (action === 'execute' || action === 'exec') return false;
+  if (sql) return _isReadOp(sql);
+  return false;
+}
+
+/**
+ * 从模块 options 定义中递归提取默认配置
+ * 支持扁平键(default)与嵌套对象(properties)，如 master.properties.host.default
+ * @param {object} options 模块 options 定义
+ * @returns {object} 提取的默认配置
+ */
+function _extractDefaults(options) {
+  var out = {};
+  for (var k in options) {
+    var o = options[k];
+    if (o && typeof o === 'object' && o.default !== undefined) {
+      out[k] = o.default;
+    } else if (o && typeof o === 'object' && o.properties) {
+      out[k] = _extractDefaults(o.properties);
+    }
+  }
+  return out;
+}
+
+/**
+ * 主函数
+ * @param {object} ctx 上下文
+ * @param {object} params 参数
+ * @returns {object} 执行结果
+ */
+async function main(params, ctx, options) {
+  const { mysqlAdmin } = require('mm_mysql');
+  // 从模块 options 读取主从配置，无 master 键时以扁平 options 作为主库
+  var rw_opts = _extractDefaults((this.config && this.config.options) || {});
+  var master_cfg;
+  var replicas = [];
+  if (rw_opts.master) {
+    master_cfg = rw_opts.master;
+    replicas = rw_opts.replicas || [];
+  } else {
+    master_cfg = rw_opts;
+    replicas = [];
+  }
+
+  var action = params.action || '';
+  var sql = params.sql || '';
+  var values = params.values || [];
+  var table = params.table || '';
+  var query = params.query || {};
+  var body = params.body || {};
+
+  // 读写分离路由
+  var is_read = _isReadAction(action, sql);
+  var target_cfg = master_cfg;
+  var route = 'master';
+
+  if (is_read && replicas.length > 0) {
+    var replica = _pickReplica(replicas);
+    if (replica) {
+      target_cfg = replica;
+      route = 'replica';
+    }
+  }
+
+  // SQL 方法必须提供 sql 语句
+  var SQL_ACTIONS = ['query', 'run', 'insert', 'update', 'delete', 'execute', 'exec', 'runSql'];
+  if (SQL_ACTIONS.indexOf(action) !== -1 && !sql) {
+    ctx.output = { error: { code: 'SQL_EMPTY', message: 'SQL 语句不能为空' } };
+    return ctx.output;
+  }
+
+  try {
+    // 使用 mm_mysql 的 mysqlAdmin 管理连接池（按 scope 缓存实例）
+    var scope = route === 'replica' ? 'rw_replica' : 'rw_master';
+    var mysql = mysqlAdmin(scope, target_cfg);
+    await mysql.open();
+
+    // ORM 方法: add/set/del/getObj/list/count
+    var ORM_METHODS = ['add', 'del', 'set', 'list', 'getObj', 'count'];
+    if (ORM_METHODS.indexOf(action) !== -1) {
+      if (!table) {
+        ctx.output = { error: { code: 'SQL_TABLE_EMPTY', message: 'ORM 操作缺少 table 参数', route: route } };
+        return ctx.output;
+      }
+      var db = mysql.db();
+      db.table = table;
+      var result;
+      switch (action) {
+        case 'add':
+          result = await db.add(body);
+          break;
+        case 'del':
+          result = await db.del(query);
+          break;
+        case 'set':
+          result = await db.set(query, body);
+          break;
+        case 'list':
+          result = await db.list(query);
+          break;
+        case 'getObj':
+          result = await db.getObj(query);
+          break;
+        case 'count':
+          result = await db.count(query);
+          break;
+      }
+      if (db.error) {
+        ctx.output = { error: { code: 'ORM_ERROR', message: db.error.message, route: route } };
+        return ctx.output;
+      }
+      ctx.output = { result: result, route: route };
+      return ctx.output;
+    }
+
+    // SQL 方法: query / insert / update / delete / execute
+    switch (action) {
+      case 'runSql': {
+        var rs = await mysql.runSql(sql);
+        if (mysql.error) {
+          ctx.output = { error: { code: 'SQL_ERROR', message: mysql.error.message, route: route } };
+          return ctx.output;
+        }
+        ctx.output = {
+          success: rs.success,
+          statements: rs.statements,
+          affected_rows: rs.affected_rows,
+          route: route
+        };
+        break;
+      }
+      case 'query':
+      case 'run': {
+        var rows = await mysql.run(sql, values);
+        if (mysql.error) {
+          ctx.output = { error: { code: 'SQL_ERROR', message: mysql.error.message, route: route } };
+          return ctx.output;
+        }
+        ctx.output = {
+          list: Array.isArray(rows) ? rows : [],
+          count: Array.isArray(rows) ? rows.length : 0,
+          route: route
+        };
+        break;
+      }
+      case 'insert':
+      case 'update':
+      case 'delete':
+      case 'execute':
+      case 'exec': {
+        var affected = await mysql.exec(sql, values);
+        if (mysql.error) {
+          ctx.output = { error: { code: 'SQL_ERROR', message: mysql.error.message, route: route } };
+          return ctx.output;
+        }
+        ctx.output = {
+          affected: affected || 0,
+          route: route
+        };
+        break;
+      }
+      default:
+        ctx.output = {
+          error: {
+            code: 'SQL_UNKNOWN_ACTION',
+            message: '不支持的操作: ' + action + '，支持: query/insert/update/delete/execute/runSql + ORM(add/set/del/getObj/list/count)',
+            route: route
+          }
+        };
+    }
+  } catch (err) {
+    ctx.output = {
+      error: { code: 'SQL_ERROR', message: err.message, route: route }
+    };
+  }
+
+  return ctx.output;
+}
+
+module.exports = { main };

package/lib/tools/sql_dump/index.js

@@ -0,0 +1,181 @@
+/**
+ * SQL导出管理器
+ * 将数据库表导出为 SQL 文件（表结构 + 数据），基于 mm_mysql
+ * 导出内容: SHOW CREATE TABLE 建表语句 + INSERT 数据语句
+ */
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * 主函数
+ * @param {object} ctx 上下文对象
+ * @param {object} params 参数 { table, output_file }
+ * @returns {object} 导出结果 { file_path, table, statements, rows }
+ */
+async function main(params, ctx, options) {
+  const { mysqlAdmin } = require('mm_mysql');
+  var table = params.table || '';
+  var output_file = params.output_file || '';
+  // 未提供的可选参数在模板中会保留为占位符，此时使用默认输出路径
+  if (output_file.indexOf('{{') !== -1) {
+    output_file = '';
+  }
+
+  if (!table) {
+    ctx.output = _errorResult('MGR_TABLE_EMPTY', '表名不能为空');
+    return ctx.output;
+  }
+
+  var opts = this.getOptions();
+
+  try {
+    var mysql = mysqlAdmin('os', opts);
+    await mysql.open();
+
+    var create_sql = await _getCreateSql(mysql, table);
+    if (mysql.error) {
+      ctx.output = _errorResult('MGR_DUMP_ERROR', '查询表结构失败: ' + mysql.error.message);
+      return ctx.output;
+    }
+
+    var rows = await _getRows(mysql, table);
+    if (mysql.error) {
+      ctx.output = _errorResult('MGR_DUMP_ERROR', '查询表数据失败: ' + mysql.error.message);
+      return ctx.output;
+    }
+
+    var insert_sqls = _buildInserts(table, rows);
+    var sql_text = _buildSqlText(table, create_sql, insert_sqls);
+    var file_path = _writeFile(table, sql_text, output_file);
+
+    ctx.output = {
+      file_path: file_path,
+      table: table,
+      statements: 1 + insert_sqls.length,
+      rows: rows.length
+    };
+    return ctx.output;
+  } catch (err) {
+    ctx.output = _errorResult('MGR_DUMP_ERROR', err.message);
+    return ctx.output;
+  }
+}
+
+/**
+ * 查询表结构
+ * @param {object} mysql 数据库实例
+ * @param {string} table 表名
+ * @returns {string} 建表语句
+ */
+async function _getCreateSql(mysql, table) {
+  var list = await mysql.run('SHOW CREATE TABLE `' + table + '`', []);
+  if (!Array.isArray(list) || list.length === 0) {
+    return '';
+  }
+  var first = list[0];
+  var create_sql = first['Create Table'] || Object.values(first).pop() || '';
+  create_sql = String(create_sql).trim();
+  if (create_sql && !create_sql.endsWith(';')) {
+    create_sql += ';';
+  }
+  return create_sql;
+}
+
+/**
+ * 查询表数据
+ * @param {object} mysql 数据库实例
+ * @param {string} table 表名
+ * @returns {Array} 数据行数组
+ */
+async function _getRows(mysql, table) {
+  var list = await mysql.run('SELECT * FROM `' + table + '`', []);
+  return Array.isArray(list) ? list : [];
+}
+
+/**
+ * 生成 INSERT 语句数组
+ * @param {string} table 表名
+ * @param {Array} rows 数据行
+ * @returns {Array} INSERT 语句数组
+ */
+function _buildInserts(table, rows) {
+  var sqls = [];
+  for (var i = 0; i < rows.length; i++) {
+    var row = rows[i];
+    var cols = Object.keys(row);
+    var vals = [];
+    for (var j = 0; j < cols.length; j++) {
+      vals.push(_sqlValue(row[cols[j]]));
+    }
+    sqls.push(
+      'INSERT INTO `' + table + '` (`' + cols.join('`, `') + '`) VALUES (' + vals.join(', ') + ');'
+    );
+  }
+  return sqls;
+}
+
+/**
+ * 转换值为 SQL 字面量
+ * @param {*} value 字段值
+ * @returns {string} SQL 字面量
+ */
+function _sqlValue(value) {
+  if (value === null || value === undefined) return 'NULL';
+  if (typeof value === 'number') return String(value);
+  if (typeof value === 'boolean') return value ? '1' : '0';
+  if (value instanceof Date) {
+    var dt = value.toISOString().slice(0, 19).replace('T', ' ');
+    return "'" + dt + "'";
+  }
+  return "'" + String(value).replace(/'/g, "''") + "'";
+}
+
+/**
+ * 拼接完整导出 SQL 文本
+ * @param {string} table 表名
+ * @param {string} create_sql 建表语句
+ * @param {Array} insert_sqls INSERT 语句数组
+ * @returns {string} 完整 SQL 文本
+ */
+function _buildSqlText(table, create_sql, insert_sqls) {
+  var lines = [];
+  lines.push('-- 表结构导出: `' + table + '`');
+  lines.push(create_sql);
+  if (insert_sqls.length > 0) {
+    lines.push('');
+    lines.push('-- 表数据导出: `' + table + '` (' + insert_sqls.length + ' 行)');
+    for (var i = 0; i < insert_sqls.length; i++) {
+      lines.push(insert_sqls[i]);
+    }
+  }
+  return lines.join('\n') + '\n';
+}
+
+/**
+ * 写入导出文件
+ * @param {string} table 表名
+ * @param {string} sql_text SQL 内容
+ * @param {string} output_file 输出路径（可选）
+ * @returns {string} 文件绝对路径
+ */
+function _writeFile(table, sql_text, output_file) {
+  var base = process.cwd();
+  var file_path = output_file
+    ? path.resolve(base, output_file)
+    : path.resolve(base, 'backup', table + '.sql');
+  fs.mkdirSync(path.dirname(file_path), { recursive: true });
+  fs.writeFileSync(file_path, sql_text, 'utf8');
+  return file_path;
+}
+
+/**
+ * 构建错误结果对象
+ * @param {string} code 错误码
+ * @param {string} message 错误信息
+ * @returns {object} 错误对象
+ */
+function _errorResult(code, message) {
+  return { error: { code: code, message: message } };
+}
+
+module.exports = { main };