gcl/com/coooders/db/mysql2.js

码农村nodejs类库，完成解决回调陷阱，配置框架，IOC框架，统一多DB访问框架，可扩展日志框架和io/db/net/thread/pool 克隆表达式，加解密算法等等一系列基础类库和算法的实现

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.NiMySQLDataFactory = undefined;

var _regenerator = require("babel-runtime/regenerator");

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require("babel-runtime/helpers/asyncToGenerator");

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _get2 = require("babel-runtime/helpers/get");

var _get3 = _interopRequireDefault(_get2);

var _getPrototypeOf = require("babel-runtime/core-js/object/get-prototype-of");

var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);

var _classCallCheck2 = require("babel-runtime/helpers/classCallCheck");

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require("babel-runtime/helpers/createClass");

var _createClass3 = _interopRequireDefault(_createClass2);

var _possibleConstructorReturn2 = require("babel-runtime/helpers/possibleConstructorReturn");

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

var _inherits2 = require("babel-runtime/helpers/inherits");

var _inherits3 = _interopRequireDefault(_inherits2);

var _tool = require("../common/tool");

var _tool2 = _interopRequireDefault(_tool);

var _promise = require("mysql2/promise");

var _promise2 = _interopRequireDefault(_promise);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var pri = _tool2.default.pris();

/**
 * MySQL 池连接方式工厂
 */
var NiMySQLDataFactory = exports.NiMySQLDataFactory = function (_NiDataFactory) {
  (0, _inherits3.default)(NiMySQLDataFactory, _NiDataFactory);

  function NiMySQLDataFactory() {
    (0, _classCallCheck3.default)(this, NiMySQLDataFactory);

    var _this = (0, _possibleConstructorReturn3.default)(this, (NiMySQLDataFactory.__proto__ || (0, _getPrototypeOf2.default)(NiMySQLDataFactory)).call(this));

    var that = _this;
    that.idic = {};

    var _pri = pri(that, {
      MySQLConnection: function (_NiDataConnection) {
        (0, _inherits3.default)(MySQLConnection, _NiDataConnection);

        function MySQLConnection() {
          var _this3 = this;

          (0, _classCallCheck3.default)(this, MySQLConnection);

          var _this2 = (0, _possibleConstructorReturn3.default)(this, (MySQLConnection.__proto__ || (0, _getPrototypeOf2.default)(MySQLConnection)).call(this));

          var that = _this2;

          var _pri2 = pri(_this2, {
            cmds: [],
            conn: null,
            getValue: function getValue(p) {
              return p.value;
            },
            toList: function toList(vals) {
              var _pri3 = pri(that),
                  _ = _pri3._,
                  __ = _pri3.__;

              if (vals[0]) {
                var ret = [];
                for (var i = 0; i < vals.length; i++) {
                  ret.push(__.toList(vals[i]));
                }return ret;
              } else return function () {
                var ret = {};
                for (var k in vals) {
                  switch (_tool2.default.getType(vals[k]).toLowerCase()) {
                    case "date":
                    case "number":
                    case "boolean":
                    case "string":
                    case "null":
                      ret[k] = vals[k];
                      break;
                    case "uint8array":
                      // ret[k] = parseInt(Buffer.from(vals[k])[0]);
                      ret[k] = Buffer.from(vals[k]).toString();
                      break;
                  }
                }
                return ret;
              }();
            },
            invoke: function () {
              var _ref = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee(command, params) {
                var _pri4, _2, _3, result, data, i;

                return _regenerator2.default.wrap(function _callee$(_context) {
                  while (1) {
                    switch (_context.prev = _context.next) {
                      case 0:
                        _context.prev = 0;
                        _pri4 = pri(that), _2 = _pri4._, _3 = _pri4.__;
                        _context.next = 4;
                        return _tool2.default.callback(_3.conn.query, _3.conn, _2.prepare(command, params));

                      case 4:
                        result = _context.sent;
                        data = [];

                        if (!result[0]) result = [[]];
                        //过滤mysql自定义的更新结果JSON
                        result = result.filter(function (v) {
                          return v.serverStatus == undefined;
                        });

                        //过滤mysql上复制:=
                        result = result.filter(function (v) {
                          switch (_tool2.default.getType(v)) {
                            case "object":
                            case "Object":
                              for (var k in v) {
                                if (k.indexOf(":=") >= 0) return false;
                              }
                              break;
                            case "Array":
                              var _v = v.filter(function (r) {
                                for (var k2 in r) {
                                  if (k2.indexOf(":=") >= 0) return false;
                                }
                                return true;
                              });
                              return _v.length > 0 || v.length == 0;
                          }
                          return true;
                        });
                        if (!result[0]) result = [[]];
                        if (_tool2.default.getType(result[0]).toLowerCase() != "array") result = [result];
                        //自动补充mysql在单sql下不是2个嵌套数据的问题
                        if (result && result.length > 0) for (i = 0; i < result.length; i++) {
                          if (typeof result[i] != "undefined" && result[i].length > 0) data.push(_3.toList(result[i]));else if (typeof result[i] != "undefined" && !_tool2.default.isArray(result[i])) {
                            //if (typeof(result[i].affectedRows) == 'undefined') {
                            data.push(_3.toList([result[i]]));
                          } else {
                            data.push([]);
                          }
                        } else data.push([]);
                        return _context.abrupt("return", data);

                      case 15:
                        _context.prev = 15;
                        _context.t0 = _context["catch"](0);

                        console.log(command, params);
                        console.log(_context.t0.message);
                        throw _context.t0;

                      case 20:
                      case "end":
                        return _context.stop();
                    }
                  }
                }, _callee, _this3, [[0, 15]]);
              }));

              return function invoke(_x, _x2) {
                return _ref.apply(this, arguments);
              };
            }()
          }),
              _ = _pri2._,
              __ = _pri2.__;

          _.params = {
            multipleStatements: true,
            connectionLimit: 10
          };
          return _this2;
        }

        (0, _createClass3.default)(MySQLConnection, [{
          key: "prepare",
          value: function prepare(cmd, paras) {
            var _pri5 = pri(this),
                _ = _pri5._,
                __ = _pri5.__;
            //需要将{}转成[] 处理


            if (cmd && paras) {
              var vals = [];
              cmd = cmd.replace(/\{[a-zA-Z0-9_]+\}/g, function (data) {
                try {
                  data = data.substr(1, data.length - 2);
                  return __.getValue(paras[data]);
                } catch (e) {
                  throw data + "未找到参数定义";
                }
              }).replace(/\?[a-zA-Z0-9_]+/g, function (data) {
                try {
                  vals.push(__.getValue(paras[data.trim("?")]));
                  return "?";
                } catch (e) {
                  throw data.trim("?") + "未找到参数定义";
                }
              });
              return {
                sql: cmd,
                values: vals,
                timeout: _.params.timeout || 60000 //1分钟
              };
            } else throw new Error("prepare方法要求写入command参数与paras参数");
          }
        }, {
          key: "invoke",
          value: function () {
            var _ref2 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee2(cmd) {
              var _pri6, _, __;

              return _regenerator2.default.wrap(function _callee2$(_context2) {
                while (1) {
                  switch (_context2.prev = _context2.next) {
                    case 0:
                      //需要处理单条与多条s
                      _pri6 = pri(this), _ = _pri6._, __ = _pri6.__;

                      if (!_.transaction) {
                        _context2.next = 5;
                        break;
                      }

                      __.cmds.push({
                        command: cmd.command,
                        params: cmd.params
                      });
                      _context2.next = 8;
                      break;

                    case 5:
                      _context2.next = 7;
                      return __.invoke(cmd.command, cmd.params);

                    case 7:
                      return _context2.abrupt("return", _context2.sent);

                    case 8:
                    case "end":
                      return _context2.stop();
                  }
                }
              }, _callee2, this);
            }));

            function invoke(_x3) {
              return _ref2.apply(this, arguments);
            }

            return invoke;
          }()
        }, {
          key: "commit",
          value: function () {
            var _ref3 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee4() {
              var _this4 = this;

              var _pri7, _, __, data, cmds;

              return _regenerator2.default.wrap(function _callee4$(_context4) {
                while (1) {
                  switch (_context4.prev = _context4.next) {
                    case 0:
                      _pri7 = pri(this), _ = _pri7._, __ = _pri7.__;

                      if (!_.transaction) {
                        _context4.next = 22;
                        break;
                      }

                      _context4.prev = 2;
                      _context4.next = 5;
                      return _tool2.default.callback(__.conn.beginTransaction, __.conn);

                    case 5:
                      data = [];
                      cmds = __.cmds;

                      __.cmds = [];
                      _context4.next = 10;
                      return _tool2.default.each(cmds, function () {
                        var _ref4 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee3(v) {
                          return _regenerator2.default.wrap(function _callee3$(_context3) {
                            while (1) {
                              switch (_context3.prev = _context3.next) {
                                case 0:
                                  _context3.t0 = data;
                                  _context3.next = 3;
                                  return __.invoke(v.command, v.params);

                                case 3:
                                  _context3.t1 = _context3.sent;

                                  _context3.t0.push.call(_context3.t0, _context3.t1);

                                  return _context3.abrupt("return", false);

                                case 6:
                                case "end":
                                  return _context3.stop();
                              }
                            }
                          }, _callee3, _this4);
                        }));

                        return function (_x4) {
                          return _ref4.apply(this, arguments);
                        };
                      }(), true);

                    case 10:
                      _context4.next = 12;
                      return _tool2.default.callback(__.conn.commit, __.conn);

                    case 12:
                      return _context4.abrupt("return", data);

                    case 15:
                      _context4.prev = 15;
                      _context4.t0 = _context4["catch"](2);
                      _context4.next = 19;
                      return _tool2.default.callback(__.conn.rollback, __.conn);

                    case 19:
                      throw _context4.t0;

                    case 20:
                      _context4.next = 23;
                      break;

                    case 22:
                      throw new Error("非事务条件下不可调用此方法");

                    case 23:
                    case "end":
                      return _context4.stop();
                  }
                }
              }, _callee4, this, [[2, 15]]);
            }));

            function commit() {
              return _ref3.apply(this, arguments);
            }

            return commit;
          }()
        }, {
          key: "open",
          value: function () {
            var _ref5 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee7() {
              var _pri8, _, __, key, getonconn;

              return _regenerator2.default.wrap(function _callee7$(_context7) {
                while (1) {
                  switch (_context7.prev = _context7.next) {
                    case 0:
                      _pri8 = pri(this), _ = _pri8._, __ = _pri8.__;
                      key = _tool2.default.hash2(_tool2.default.toJsonString(_.params));

                      that.idic[key] = that.idic[key] || _promise2.default.createPool(_.params);

                      getonconn = function () {
                        var _ref6 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee6() {
                          var conn;
                          return _regenerator2.default.wrap(function _callee6$(_context6) {
                            while (1) {
                              switch (_context6.prev = _context6.next) {
                                case 0:
                                  _context6.next = 2;
                                  return _tool2.default.callback(that.idic[key].getConnection, that.idic[key]);

                                case 2:
                                  conn = _context6.sent;

                                  conn._key = key;
                                  if (!!!conn._ison) {
                                    conn._ison = true;
                                    conn.on("error", function () {
                                      var _ref7 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee5(err) {
                                        return _regenerator2.default.wrap(function _callee5$(_context5) {
                                          while (1) {
                                            switch (_context5.prev = _context5.next) {
                                              case 0:
                                                if (!(err.code == "PROTOCOL_CONNECTION_LOST" || err.code == "PROTOCOL_ENQUEUE_AFTER_FATAL_ERROR")) {
                                                  _context5.next = 5;
                                                  break;
                                                }

                                                try {
                                                  //conn.close();
                                                  that.idic[key] && that.idic[key].releaseConnection(conn);
                                                } catch (e) {}
                                                _context5.next = 4;
                                                return getonconn();

                                              case 4:
                                                __.conn = _context5.sent;

                                              case 5:
                                              case "end":
                                                return _context5.stop();
                                            }
                                          }
                                        }, _callee5, this);
                                      }));

                                      return function (_x5) {
                                        return _ref7.apply(this, arguments);
                                      };
                                    }());
                                  }

                                  return _context6.abrupt("return", conn);

                                case 6:
                                case "end":
                                  return _context6.stop();
                              }
                            }
                          }, _callee6, this);
                        }));

                        return function getonconn() {
                          return _ref6.apply(this, arguments);
                        };
                      }();

                      _context7.next = 6;
                      return getonconn();

                    case 6:
                      __.conn = _context7.sent;
                      _context7.next = 9;
                      return (0, _get3.default)(MySQLConnection.prototype.__proto__ || (0, _getPrototypeOf2.default)(MySQLConnection.prototype), "open", this).call(this);

                    case 9:
                    case "end":
                      return _context7.stop();
                  }
                }
              }, _callee7, this);
            }));

            function open() {
              return _ref5.apply(this, arguments);
            }

            return open;
          }()
        }, {
          key: "close",
          value: function () {
            var _ref8 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee8() {
              var _pri9, _, __;

              return _regenerator2.default.wrap(function _callee8$(_context8) {
                while (1) {
                  switch (_context8.prev = _context8.next) {
                    case 0:
                      _pri9 = pri(this), _ = _pri9._, __ = _pri9.__;

                      try {
                        if (__.conn && __.conn._key && that.idic[__.conn._key]) that.idic[__.conn._key].releaseConnection(__.conn);else if (__.conn && __.conn.end) __.conn.end();else if (__.conn && __.conn.dispose) __.conn.dispose();
                      } catch (e) {}
                      __.cmds = [];
                      __.conn = null;
                      _context8.next = 6;
                      return (0, _get3.default)(MySQLConnection.prototype.__proto__ || (0, _getPrototypeOf2.default)(MySQLConnection.prototype), "close", this).call(this);

                    case 6:
                    case "end":
                      return _context8.stop();
                  }
                }
              }, _callee8, this);
            }));

            function close() {
              return _ref8.apply(this, arguments);
            }

            return close;
          }()
        }]);
        return MySQLConnection;
      }(NiDataConnection)
    }),
        _ = _pri._,
        __ = _pri.__;

    return _this;
  }

  (0, _createClass3.default)(NiMySQLDataFactory, [{
    key: "createDBConnection",
    value: function createDBConnection() {
      var _pri10 = pri(this),
          _ = _pri10._,
          __ = _pri10.__;

      return new __.MySQLConnection();
    }
  }, {
    key: "dispose",
    value: function dispose() {
      var _this5 = this;

      for (var i in this.idic) {
        if (this.idic[i] && this.idic[i].dispose) {
          (function () {
            var v = _this5.idic[i];
            _tool2.default.tryC(function () {
              v.dispose();
            });
          })();
        }
      }
    }
  }]);
  return NiMySQLDataFactory;
}(NiDataFactory);

exports.default = {
  NiMySQLDataFactory: NiMySQLDataFactory
};
//# sourceMappingURL=mysql2.js.map