mysql2-core 0.3.4 → 0.3.6

package/lib/index.js

@@ -1,15 +1,3 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-  __assign = Object.assign || function(t) {
-    for (var s, i = 1, n = arguments.length; i < n; i++) {
-      s = arguments[i];
-      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-        t[p] = s[p];
-    }
-    return t;
-  };
-  return __assign.apply(this, arguments);
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
   function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
   return new (P || (P = Promise))(function (resolve, reject) {
@@ -19,57 +7,306 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-  var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-  return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-  function verb(n) { return function (v) { return step([n, v]); }; }
-  function step(op) {
-    if (f) throw new TypeError("Generator is already executing.");
-    while (_) try {
-      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-      if (y = 0, t) op = [op[0] & 2, t.value];
-      switch (op[0]) {
-        case 0: case 1: t = op; break;
-        case 4: _.label++; return { value: op[1], done: false };
-        case 5: _.label++; y = op[1]; op = [0]; continue;
-        case 7: op = _.ops.pop(); _.trys.pop(); continue;
-        default:
-          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-          if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-          if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-          if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-          if (t[2]) _.ops.pop();
-          _.trys.pop(); continue;
+import { createPool as createPool2 } from "mysql2";
+export function param(i) {
+  return "?";
+}
+export function params(length, from) {
+  if (from == null) {
+    from = 0;
+  }
+  const ps = [];
+  for (let i = 1; i <= length; i++) {
+    ps.push(param(i + from));
+  }
+  return ps;
+}
+export function metadata(attrs) {
+  const mp = {};
+  const ks = Object.keys(attrs);
+  const ats = [];
+  const bools = [];
+  const fields = [];
+  const m = { keys: ats, fields };
+  let isMap = false;
+  for (const k of ks) {
+    const attr = attrs[k];
+    attr.name = k;
+    if (attr.key) {
+      ats.push(attr);
+    }
+    if (!attr.ignored) {
+      fields.push(k);
+    }
+    if (attr.type === "boolean") {
+      bools.push(attr);
+    }
+    if (attr.version) {
+      m.version = k;
+    }
+    const field = attr.column ? attr.column : k;
+    const s = field.toLowerCase();
+    if (s !== k) {
+      mp[s] = k;
+      isMap = true;
+    }
+  }
+  if (isMap) {
+    m.map = mp;
+  }
+  if (bools.length > 0) {
+    m.bools = bools;
+  }
+  return m;
+}
+export function buildToSave(obj, table, attrs, ver, buildParam, i) {
+  if (!i) {
+    i = 1;
+  }
+  if (!buildParam) {
+    buildParam = param;
+  }
+  const ks = Object.keys(attrs);
+  const pks = [];
+  const cols = [];
+  const values = [];
+  const args = [];
+  let isVersion = false;
+  const o = obj;
+  for (const k of ks) {
+    const attr = attrs[k];
+    attr.name = k;
+    if (attr.key) {
+      pks.push(attr);
+    }
+    let v = o[k];
+    if (v == null) {
+      v = attr.default;
+    }
+    if (v != null && !attr.ignored && !attr.noinsert) {
+      const field = attr.column ? attr.column : k;
+      cols.push(field);
+      if (k === ver) {
+        isVersion = true;
+        values.push(`${1}`);
       }
-      op = body.call(thisArg, _);
-    } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-    if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+      else {
+        if (v === "") {
+          values.push(`''`);
+        }
+        else if (typeof v === "number") {
+          values.push(toString(v));
+        }
+        else {
+          const p = buildParam(i++);
+          values.push(p);
+          if (typeof v === "boolean") {
+            if (v === true) {
+              const v2 = attr.true ? attr.true : `'1'`;
+              args.push(v2);
+            }
+            else {
+              const v2 = attr.false ? attr.false : `'0'`;
+              args.push(v2);
+            }
+          }
+          else {
+            args.push(v);
+          }
+        }
+      }
+    }
   }
-};
-function __export(m) {
-  for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+  if (!isVersion && ver && ver.length > 0) {
+    const attr = attrs[ver];
+    const field = attr.column ? attr.column : ver;
+    cols.push(field);
+    values.push(`${1}`);
+  }
+  if (pks.length === 0) {
+    if (cols.length === 0) {
+      return { query: "", params: args };
+    }
+    else {
+      const q = `insert into ${table}(${cols.join(",")})values(${values.join(",")})`;
+      return { query: q, params: args };
+    }
+  }
+  else {
+    const colSet = [];
+    for (const k of ks) {
+      const v = o[k];
+      if (v !== undefined) {
+        const attr = attrs[k];
+        if (attr && !attr.key && !attr.ignored && !attr.noupdate) {
+          const field = attr.column ? attr.column : k;
+          let x;
+          if (v === null) {
+            x = "null";
+          }
+          else if (v === "") {
+            x = `''`;
+          }
+          else if (typeof v === "number") {
+            x = toString(v);
+          }
+          else {
+            x = buildParam(i++);
+            if (typeof v === "boolean") {
+              if (v === true) {
+                const v2 = attr.true ? "" + attr.true : `'1'`;
+                args.push(v2);
+              }
+              else {
+                const v2 = attr.false ? "" + attr.false : `'0'`;
+                args.push(v2);
+              }
+            }
+            else {
+              args.push(v);
+            }
+          }
+          colSet.push(`${field}=${x}`);
+        }
+      }
+    }
+    if (colSet.length === 0) {
+      const q = `insert ignore into ${table}(${cols.join(",")})values(${values.join(",")})`;
+      return { query: q, params: args };
+    }
+    else {
+      const q = `insert into ${table}(${cols.join(",")})values(${values.join(",")}) on duplicate key update ${colSet.join(",")}`;
+      return { query: q, params: args };
+    }
+  }
+}
+export function buildToSaveBatch(objs, table, attrs, ver, buildParam) {
+  if (!buildParam) {
+    buildParam = param;
+  }
+  const sts = [];
+  const ks = Object.keys(attrs);
+  for (const obj of objs) {
+    let i = 1;
+    const cols = [];
+    const values = [];
+    const args = [];
+    let isVersion = false;
+    const o = obj;
+    for (const k of ks) {
+      const attr = attrs[k];
+      let v = o[k];
+      if (v == null) {
+        v = attr.default;
+      }
+      if (v != null && v !== undefined && !attr.ignored && !attr.noinsert) {
+        const field = attr.column ? attr.column : k;
+        cols.push(field);
+        if (k === ver) {
+          isVersion = true;
+          values.push(`${1}`);
+        }
+        else {
+          if (v === "") {
+            values.push(`''`);
+          }
+          else if (typeof v === "number") {
+            values.push(toString(v));
+          }
+          else {
+            const p = buildParam(i++);
+            values.push(p);
+            if (typeof v === "boolean") {
+              if (v === true) {
+                const v2 = attr.true ? attr.true : `'1'`;
+                args.push(v2);
+              }
+              else {
+                const v2 = attr.false ? attr.false : `'0'`;
+                args.push(v2);
+              }
+            }
+            else {
+              args.push(v);
+            }
+          }
+        }
+      }
+    }
+    if (!isVersion && ver && ver.length > 0) {
+      const attr = attrs[ver];
+      const field = attr.column ? attr.column : ver;
+      cols.push(field);
+      values.push(`${1}`);
+    }
+    const colSet = [];
+    for (const k of ks) {
+      const v = o[k];
+      if (v !== undefined) {
+        const attr = attrs[k];
+        if (attr && !attr.key && !attr.ignored && k !== ver && !attr.noupdate) {
+          const field = attr.column ? attr.column : k;
+          let x;
+          if (v === null) {
+            x = "null";
+          }
+          else if (v === "") {
+            x = `''`;
+          }
+          else if (typeof v === "number") {
+            x = toString(v);
+          }
+          else {
+            x = buildParam(i++);
+            if (typeof v === "boolean") {
+              if (v === true) {
+                const v2 = attr.true ? "" + attr.true : `'1'`;
+                args.push(v2);
+              }
+              else {
+                const v2 = attr.false ? "" + attr.false : `'0'`;
+                args.push(v2);
+              }
+            }
+            else {
+              args.push(v);
+            }
+          }
+          colSet.push(`${field}=${x}`);
+        }
+      }
+    }
+    if (colSet.length === 0) {
+      const q = `insert ignore into ${table}(${cols.join(",")})values(${values.join(",")});`;
+      const smt = { query: q, params: args };
+      sts.push(smt);
+    }
+    else {
+      const q = `insert into ${table}(${cols.join(",")})values(${values.join(",")}) on duplicate key update ${colSet.join(",")};`;
+      const smt = { query: q, params: args };
+      sts.push(smt);
+    }
+  }
+  return sts;
+}
+export function toString(v) {
+  if (v === v && v !== Infinity && v !== -Infinity) {
+    return "" + v;
+  }
+  return "null";
 }
-Object.defineProperty(exports, "__esModule", { value: true });
-var mysql2_1 = require("mysql2");
-var build_1 = require("./build");
-__export(require("./build"));
-var resource = (function () {
-  function resource() {
-  }
-  return resource;
-}());
-exports.resource = resource;
-function createPool(conf) {
+export class resource {
+}
+export function createPool(conf) {
   if (conf.max && conf.max > 0 && !conf.connectionLimit) {
     conf.connectionLimit = conf.max;
   }
-  var pool = mysql2_1.createPool(__assign(__assign({}, conf), { rowsAsArray: true }));
+  const pool = createPool2(Object.assign(Object.assign({}, conf), { rowsAsArray: true }));
   return pool;
 }
-exports.createPool = createPool;
-function getConnection(pool) {
-  return new Promise(function (resolve, reject) {
-    pool.getConnection(function (err, connection) {
+export function getConnection(pool) {
+  return new Promise((resolve, reject) => {
+    pool.getConnection((err, connection) => {
       if (err) {
         return reject(err);
       }
@@ -77,15 +314,14 @@ function getConnection(pool) {
     });
   });
 }
-exports.getConnection = getConnection;
-function beginTransaction(connection, rollbackIfError) {
-  return new Promise(function (resolve, reject) {
-    connection.beginTransaction(function (err) {
+export function beginTransaction(connection, rollbackIfError) {
+  return new Promise((resolve, reject) => {
+    connection.beginTransaction((err) => {
       if (err) {
         if (!rollbackIfError) {
           return reject(err);
         }
-        connection.rollback(function () {
+        connection.rollback(() => {
           return reject(err);
         });
       }
@@ -93,15 +329,14 @@ function beginTransaction(connection, rollbackIfError) {
     });
   });
 }
-exports.beginTransaction = beginTransaction;
-function commit(connection, rollbackIfError) {
-  return new Promise(function (resolve, reject) {
-    connection.commit(function (err) {
+export function commit(connection, rollbackIfError) {
+  return new Promise((resolve, reject) => {
+    connection.commit((err) => {
       if (err) {
         if (!rollbackIfError) {
           return reject(err);
         }
-        connection.rollback(function () {
+        connection.rollback(() => {
           return reject(err);
         });
       }
@@ -109,10 +344,9 @@ function commit(connection, rollbackIfError) {
     });
   });
 }
-exports.commit = commit;
-function rollback(connection) {
-  return new Promise(function (resolve, reject) {
-    connection.rollback(function (err) {
+export function rollback(connection) {
+  return new Promise((resolve, reject) => {
+    connection.rollback((err) => {
       if (err) {
         return reject(err);
       }
@@ -120,9 +354,8 @@ function rollback(connection) {
     });
   });
 }
-exports.rollback = rollback;
-var PoolManager = (function () {
-  function PoolManager(pool) {
+export class PoolManager {
+  constructor(pool) {
     this.pool = pool;
     this.driver = "mysql";
     this.param = this.param.bind(this);
@@ -133,57 +366,54 @@ var PoolManager = (function () {
     this.executeScalar = this.executeScalar.bind(this);
     this.count = this.count.bind(this);
   }
-  PoolManager.prototype.param = function (i) {
+  param(i) {
     return "?";
-  };
-  PoolManager.prototype.beginTransaction = function () {
-    var _this = this;
-    return new Promise(function (resolve, reject) {
-      _this.pool.getConnection(function (er0, connection) {
+  }
+  beginTransaction() {
+    return new Promise((resolve, reject) => {
+      this.pool.getConnection((er0, connection) => {
         if (er0) {
           return reject(er0);
         }
-        connection.beginTransaction(function (er1) {
+        connection.beginTransaction((er1) => {
           if (er1) {
-            connection.rollback(function () {
+            connection.rollback(() => {
               return reject(er1);
             });
           }
-          var tx = new PoolConnectionManager(connection);
+          const tx = new PoolConnectionManager(connection);
           return resolve(tx);
         });
       });
     });
-  };
-  PoolManager.prototype.execute = function (sql, args, ctx) {
-    var p = ctx ? ctx : this.pool;
+  }
+  execute(sql, args, ctx) {
+    const p = ctx ? ctx : this.pool;
     return execute(p, sql, args);
-  };
-  PoolManager.prototype.executeBatch = function (statements, firstSuccess, ctx) {
-    var p = ctx ? ctx : this.pool;
+  }
+  executeBatch(statements, firstSuccess, ctx) {
+    const p = ctx ? ctx : this.pool;
     return executeBatch(p, statements, firstSuccess);
-  };
-  PoolManager.prototype.query = function (sql, args, m, bools, ctx) {
-    var p = ctx ? ctx : this.pool;
+  }
+  query(sql, args, m, bools, ctx) {
+    const p = ctx ? ctx : this.pool;
     return query(p, sql, args, m, bools);
-  };
-  PoolManager.prototype.queryOne = function (sql, args, m, bools, ctx) {
-    var p = ctx ? ctx : this.pool;
+  }
+  queryOne(sql, args, m, bools, ctx) {
+    const p = ctx ? ctx : this.pool;
     return queryOne(p, sql, args, m, bools);
-  };
-  PoolManager.prototype.executeScalar = function (sql, args, ctx) {
-    var p = ctx ? ctx : this.pool;
+  }
+  executeScalar(sql, args, ctx) {
+    const p = ctx ? ctx : this.pool;
     return executeScalar(p, sql, args);
-  };
-  PoolManager.prototype.count = function (sql, args, ctx) {
-    var p = ctx ? ctx : this.pool;
+  }
+  count(sql, args, ctx) {
+    const p = ctx ? ctx : this.pool;
     return count(p, sql, args);
-  };
-  return PoolManager;
-}());
-exports.PoolManager = PoolManager;
-var PoolConnectionManager = (function () {
-  function PoolConnectionManager(connection) {
+  }
+}
+export class PoolConnectionManager {
+  constructor(connection) {
     this.connection = connection;
     this.driver = "mysql";
     this.param = this.param.bind(this);
@@ -194,343 +424,267 @@ var PoolConnectionManager = (function () {
     this.executeScalar = this.executeScalar.bind(this);
     this.count = this.count.bind(this);
   }
-  PoolConnectionManager.prototype.param = function (i) {
+  param(i) {
     return "?";
-  };
-  PoolConnectionManager.prototype.commit = function () {
-    var _this = this;
-    return new Promise(function (resolve, reject) {
-      _this.connection.commit(function (er3) {
+  }
+  commit() {
+    return new Promise((resolve, reject) => {
+      this.connection.commit((er3) => {
         if (er3) {
           return reject(er3);
         }
         return resolve();
       });
     });
-  };
-  PoolConnectionManager.prototype.rollback = function () {
-    var _this = this;
-    return new Promise(function (resolve, reject) {
-      _this.connection.rollback(function (er3) {
+  }
+  rollback() {
+    return new Promise((resolve, reject) => {
+      this.connection.rollback((er3) => {
         if (er3) {
           return reject(er3);
         }
         return resolve();
       });
     });
-  };
-  PoolConnectionManager.prototype.execute = function (sql, args, ctx) {
-    var p = ctx ? ctx : this.connection;
+  }
+  execute(sql, args, ctx) {
+    const p = ctx ? ctx : this.connection;
     return execute(p, sql, args);
-  };
-  PoolConnectionManager.prototype.executeBatch = function (statements, firstSuccess, ctx) {
-    var p = ctx ? ctx : this.connection;
+  }
+  executeBatch(statements, firstSuccess, ctx) {
+    const p = ctx ? ctx : this.connection;
     return executeBatchConnection(p, statements, firstSuccess);
-  };
-  PoolConnectionManager.prototype.query = function (sql, args, m, bools, ctx) {
-    var p = ctx ? ctx : this.connection;
+  }
+  query(sql, args, m, bools, ctx) {
+    const p = ctx ? ctx : this.connection;
     return query(p, sql, args, m, bools);
-  };
-  PoolConnectionManager.prototype.queryOne = function (sql, args, m, bools, ctx) {
-    var p = ctx ? ctx : this.connection;
+  }
+  queryOne(sql, args, m, bools, ctx) {
+    const p = ctx ? ctx : this.connection;
     return queryOne(p, sql, args, m, bools);
-  };
-  PoolConnectionManager.prototype.executeScalar = function (sql, args, ctx) {
-    var p = ctx ? ctx : this.connection;
+  }
+  executeScalar(sql, args, ctx) {
+    const p = ctx ? ctx : this.connection;
     return executeScalar(p, sql, args);
-  };
-  PoolConnectionManager.prototype.count = function (sql, args, ctx) {
-    var p = ctx ? ctx : this.connection;
+  }
+  count(sql, args, ctx) {
+    const p = ctx ? ctx : this.connection;
     return count(p, sql, args);
-  };
-  return PoolConnectionManager;
-}());
-exports.PoolConnectionManager = PoolConnectionManager;
-function executeBatch(pool, statements, firstSuccess) {
-  return __awaiter(this, void 0, void 0, function () {
-    return __generator(this, function (_a) {
-      if (!statements || statements.length === 0) {
-        return [2, Promise.resolve(0)];
-      }
-      else if (statements.length === 1) {
-        return [2, execute(pool, statements[0].query, statements[0].params)];
-      }
-      return [2, new Promise(function (resolve, reject) {
-          pool.getConnection(function (er0, connection) {
-            if (er0) {
-              return reject(er0);
-            }
-            return executeBatchConnectionTx(connection, statements, firstSuccess);
-          });
-        })];
+  }
+}
+export function executeBatch(pool, statements, firstSuccess) {
+  return __awaiter(this, void 0, void 0, function* () {
+    if (!statements || statements.length === 0) {
+      return Promise.resolve(0);
+    }
+    else if (statements.length === 1) {
+      return execute(pool, statements[0].query, statements[0].params);
+    }
+    return new Promise((resolve, reject) => {
+      pool.getConnection((er0, connection) => {
+        if (er0) {
+          return reject(er0);
+        }
+        return executeBatchConnectionTx(connection, statements, firstSuccess);
+      });
     });
   });
 }
-exports.executeBatch = executeBatch;
-function executeBatchConnectionTx(connection, statements, firstSuccess) {
-  return __awaiter(this, void 0, void 0, function () {
-    var count_1, l, j, item, c, err_1, count_2, l, j, item, c, err_2;
-    return __generator(this, function (_a) {
-      switch (_a.label) {
-        case 0:
-          if (!statements || statements.length === 0) {
-            return [2, Promise.resolve(0)];
-          }
-          else if (statements.length === 1) {
-            return [2, execute(connection, statements[0].query, statements[0].params)];
-          }
-          if (!resource.multipleStatements) return [3, 1];
-          if (firstSuccess) {
-            return [2, new Promise(function (resolve, reject) {
-                connection.beginTransaction(function (er1) {
-                  if (er1) {
-                    connection.rollback(function () {
-                      return reject(er1);
-                    });
-                  }
-                  else {
-                    connection.execute(statements[0].query, toArray(statements[0].params), function (er2a, results0) {
-                      if (er2a) {
-                        connection.rollback(function () {
-                          return reject(er2a);
+export function executeBatchConnectionTx(connection, statements, firstSuccess) {
+  return __awaiter(this, void 0, void 0, function* () {
+    if (!statements || statements.length === 0) {
+      return Promise.resolve(0);
+    }
+    else if (statements.length === 1) {
+      return execute(connection, statements[0].query, statements[0].params);
+    }
+    if (resource.multipleStatements) {
+      if (firstSuccess) {
+        return new Promise((resolve, reject) => {
+          connection.beginTransaction((er1) => {
+            if (er1) {
+              connection.rollback(() => {
+                return reject(er1);
+              });
+            }
+            else {
+              connection.execute(statements[0].query, toArray(statements[0].params), (er2a, results0) => {
+                if (er2a) {
+                  connection.rollback(() => {
+                    return reject(er2a);
+                  });
+                }
+                else {
+                  if (results0 && results0.affectedRows === 0) {
+                    connection.commit((er3) => {
+                      if (er3) {
+                        connection.rollback(() => {
+                          return reject(er3);
                         });
                       }
-                      else {
-                        if (results0 && results0.affectedRows === 0) {
-                          connection.commit(function (er3) {
-                            if (er3) {
-                              connection.rollback(function () {
-                                return reject(er3);
-                              });
-                            }
-                          });
-                          return 0;
-                        }
-                        else {
-                          var queries = [];
-                          var params = [];
-                          var l = statements.length;
-                          for (var j = 1; j < l; j++) {
-                            var item = statements[j];
-                            if (item.query.endsWith(";")) {
-                              queries.push(item.query);
-                            }
-                            else {
-                              queries.push(item.query + ";");
-                            }
-                            if (item.params && item.params.length > 0) {
-                              for (var _i = 0, _a = item.params; _i < _a.length; _i++) {
-                                var p = _a[_i];
-                                params.push(p);
-                              }
-                            }
-                          }
-                          connection.query(queries.join(""), toArray(params), function (er2, results) {
-                            if (er2) {
-                              connection.rollback(function () {
-                                return reject(er2);
-                              });
-                            }
-                            else {
-                              connection.commit(function (er3) {
-                                if (er3) {
-                                  connection.rollback(function () {
-                                    return reject(er3);
-                                  });
-                                }
-                              });
-                              var c = 0;
-                              c += results0.affectedRows + results.affectedRows;
-                              return resolve(c);
-                            }
-                          });
-                        }
-                      }
-                    });
-                  }
-                });
-              })];
-          }
-          else {
-            return [2, new Promise(function (resolve, reject) {
-                connection.beginTransaction(function (er1) {
-                  if (er1) {
-                    connection.rollback(function () {
-                      return reject(er1);
                     });
+                    return 0;
                   }
                   else {
-                    var queries_1 = [];
-                    var params_1 = [];
-                    statements.forEach(function (item) {
+                    const queries = [];
+                    const params = [];
+                    const l = statements.length;
+                    for (let j = 1; j < l; j++) {
+                      const item = statements[j];
                       if (item.query.endsWith(";")) {
-                        queries_1.push(item.query);
+                        queries.push(item.query);
                       }
                       else {
-                        queries_1.push(item.query + ";");
+                        queries.push(item.query + ";");
                       }
                       if (item.params && item.params.length > 0) {
-                        for (var _i = 0, _a = item.params; _i < _a.length; _i++) {
-                          var p = _a[_i];
-                          params_1.push(p);
+                        for (const p of item.params) {
+                          params.push(p);
                         }
                       }
-                    });
-                    connection.query(queries_1.join(""), toArray(params_1), function (er2, results) {
+                    }
+                    connection.query(queries.join(""), toArray(params), (er2, results) => {
                       if (er2) {
-                        connection.rollback(function () {
-                          buildError(er2);
+                        connection.rollback(() => {
                           return reject(er2);
                         });
                       }
                       else {
-                        connection.commit(function (er3) {
+                        connection.commit((er3) => {
                           if (er3) {
-                            connection.rollback(function () {
+                            connection.rollback(() => {
                               return reject(er3);
                             });
                           }
                         });
-                        return resolve(results.affectedRows);
+                        let c = 0;
+                        c += results0.affectedRows + results.affectedRows;
+                        return resolve(c);
                       }
                     });
                   }
-                });
-              })];
-          }
-          return [3, 18];
-        case 1:
-          if (!firstSuccess) return [3, 11];
-          _a.label = 2;
-        case 2:
-          _a.trys.push([2, 9, , 10]);
-          return [4, beginTransaction(connection, true)];
-        case 3:
-          _a.sent();
-          return [4, execute(connection, statements[0].query, toArray(statements[0].params))];
-        case 4:
-          count_1 = _a.sent();
-          if (count_1 === 0) {
+                }
+              });
+            }
+          });
+        });
+      }
+      else {
+        return new Promise((resolve, reject) => {
+          connection.beginTransaction((er1) => {
+            if (er1) {
+              connection.rollback(() => {
+                return reject(er1);
+              });
+            }
+            else {
+              const queries = [];
+              const params = [];
+              statements.forEach((item) => {
+                if (item.query.endsWith(";")) {
+                  queries.push(item.query);
+                }
+                else {
+                  queries.push(item.query + ";");
+                }
+                if (item.params && item.params.length > 0) {
+                  for (const p of item.params) {
+                    params.push(p);
+                  }
+                }
+              });
+              connection.query(queries.join(""), toArray(params), (er2, results) => {
+                if (er2) {
+                  connection.rollback(() => {
+                    buildError(er2);
+                    return reject(er2);
+                  });
+                }
+                else {
+                  connection.commit((er3) => {
+                    if (er3) {
+                      connection.rollback(() => {
+                        return reject(er3);
+                      });
+                    }
+                  });
+                  return resolve(results.affectedRows);
+                }
+              });
+            }
+          });
+        });
+      }
+    }
+    else {
+      if (firstSuccess) {
+        try {
+          yield beginTransaction(connection, true);
+          let count = yield execute(connection, statements[0].query, toArray(statements[0].params));
+          if (count === 0) {
             commit(connection, true);
-            return [2, 0];
+            return 0;
+          }
+          const l = statements.length;
+          for (let j = 1; j < l; j++) {
+            const item = statements[j];
+            const c = yield execute(connection, item.query, toArray(item.params));
+            count = count + c;
           }
-          l = statements.length;
-          j = 1;
-          _a.label = 5;
-        case 5:
-          if (!(j < l)) return [3, 8];
-          item = statements[j];
-          return [4, execute(connection, item.query, toArray(item.params))];
-        case 6:
-          c = _a.sent();
-          count_1 = count_1 + c;
-          _a.label = 7;
-        case 7:
-          j++;
-          return [3, 5];
-        case 8:
           commit(connection, true);
-          return [2, count_1];
-        case 9:
-          err_1 = _a.sent();
+          return count;
+        }
+        catch (err) {
           rollback(connection);
-          throw err_1;
-        case 10: return [3, 18];
-        case 11:
-          _a.trys.push([11, 17, , 18]);
-          return [4, beginTransaction(connection, true)];
-        case 12:
-          _a.sent();
-          count_2 = 0;
-          l = statements.length;
-          j = 0;
-          _a.label = 13;
-        case 13:
-          if (!(j < l)) return [3, 16];
-          item = statements[j];
-          return [4, execute(connection, item.query, toArray(item.params))];
-        case 14:
-          c = _a.sent();
-          count_2 = count_2 + c;
-          _a.label = 15;
-        case 15:
-          j++;
-          return [3, 13];
-        case 16:
+          throw err;
+        }
+      }
+      else {
+        try {
+          yield beginTransaction(connection, true);
+          let count = 0;
+          const l = statements.length;
+          for (let j = 0; j < l; j++) {
+            const item = statements[j];
+            const c = yield execute(connection, item.query, toArray(item.params));
+            count = count + c;
+          }
           commit(connection, true);
-          return [2, count_2];
-        case 17:
-          err_2 = _a.sent();
+          return count;
+        }
+        catch (err) {
           rollback(connection);
-          throw err_2;
-        case 18: return [2];
+          throw err;
+        }
       }
-    });
+    }
   });
 }
-exports.executeBatchConnectionTx = executeBatchConnectionTx;
-function executeBatchConnection(connection, statements, firstSuccess) {
-  return __awaiter(this, void 0, void 0, function () {
-    var count_3, l, j, item, c, er1_1, er0_1, count_4, l, j, item, c, err_3;
-    return __generator(this, function (_a) {
-      switch (_a.label) {
-        case 0:
-          if (!statements || statements.length === 0) {
-            return [2, Promise.resolve(0)];
-          }
-          else if (statements.length === 1) {
-            return [2, execute(connection, statements[0].query, statements[0].params)];
-          }
-          if (!resource.multipleStatements) return [3, 1];
-          if (firstSuccess) {
-            return [2, new Promise(function (resolve, reject) {
-                connection.execute(statements[0].query, toArray(statements[0].params), function (er2a, results0) {
-                  if (er2a) {
-                    return reject(er2a);
-                  }
-                  else {
-                    if (results0 && results0.affectedRows === 0) {
-                      return 0;
-                    }
-                    else {
-                      var queries = [];
-                      var params = [];
-                      var l = statements.length;
-                      for (var j = 1; j < l; j++) {
-                        var item = statements[j];
-                        if (item.query.endsWith(";")) {
-                          queries.push(item.query);
-                        }
-                        else {
-                          queries.push(item.query + ";");
-                        }
-                        if (item.params && item.params.length > 0) {
-                          for (var _i = 0, _a = item.params; _i < _a.length; _i++) {
-                            var p = _a[_i];
-                            params.push(p);
-                          }
-                        }
-                      }
-                      connection.query(queries.join(""), toArray(params), function (er2, results) {
-                        if (er2) {
-                          return reject(er2);
-                        }
-                        else {
-                          var c = 0;
-                          c += results0.affectedRows + results.affectedRows;
-                          return resolve(c);
-                        }
-                      });
-                    }
-                  }
-                });
-              })];
-          }
-          else {
-            return [2, new Promise(function (resolve, reject) {
-                var queries = [];
-                var params = [];
-                statements.forEach(function (item) {
+export function executeBatchConnection(connection, statements, firstSuccess) {
+  return __awaiter(this, void 0, void 0, function* () {
+    if (!statements || statements.length === 0) {
+      return Promise.resolve(0);
+    }
+    else if (statements.length === 1) {
+      return execute(connection, statements[0].query, statements[0].params);
+    }
+    if (resource.multipleStatements) {
+      if (firstSuccess) {
+        return new Promise((resolve, reject) => {
+          connection.execute(statements[0].query, toArray(statements[0].params), (er2a, results0) => {
+            if (er2a) {
+              return reject(er2a);
+            }
+            else {
+              if (results0 && results0.affectedRows === 0) {
+                return 0;
+              }
+              else {
+                const queries = [];
+                const params = [];
+                const l = statements.length;
+                for (let j = 1; j < l; j++) {
+                  const item = statements[j];
                   if (item.query.endsWith(";")) {
                     queries.push(item.query);
                   }
@@ -538,181 +692,177 @@ function executeBatchConnection(connection, statements, firstSuccess) {
                     queries.push(item.query + ";");
                   }
                   if (item.params && item.params.length > 0) {
-                    for (var _i = 0, _a = item.params; _i < _a.length; _i++) {
-                      var p = _a[_i];
+                    for (const p of item.params) {
                       params.push(p);
                     }
                   }
-                });
-                connection.query(queries.join(""), toArray(params), function (er2, results) {
+                }
+                connection.query(queries.join(""), toArray(params), (er2, results) => {
                   if (er2) {
-                    connection.rollback(function () {
-                      buildError(er2);
-                      return reject(er2);
-                    });
+                    return reject(er2);
                   }
                   else {
-                    connection.commit(function (er3) {
-                      if (er3) {
-                        connection.rollback(function () {
-                          return reject(er3);
-                        });
-                      }
-                    });
-                    return resolve(results.affectedRows);
+                    let c = 0;
+                    c += results0.affectedRows + results.affectedRows;
+                    return resolve(c);
                   }
                 });
-              })];
+              }
+            }
+          });
+        });
+      }
+      else {
+        return new Promise((resolve, reject) => {
+          const queries = [];
+          const params = [];
+          statements.forEach((item) => {
+            if (item.query.endsWith(";")) {
+              queries.push(item.query);
+            }
+            else {
+              queries.push(item.query + ";");
+            }
+            if (item.params && item.params.length > 0) {
+              for (const p of item.params) {
+                params.push(p);
+              }
+            }
+          });
+          connection.query(queries.join(""), toArray(params), (er2, results) => {
+            if (er2) {
+              connection.rollback(() => {
+                buildError(er2);
+                return reject(er2);
+              });
+            }
+            else {
+              connection.commit((er3) => {
+                if (er3) {
+                  connection.rollback(() => {
+                    return reject(er3);
+                  });
+                }
+              });
+              return resolve(results.affectedRows);
+            }
+          });
+        });
+      }
+    }
+    else {
+      if (firstSuccess) {
+        try {
+          let count = yield execute(connection, statements[0].query, toArray(statements[0].params));
+          if (count === 0) {
+            return 0;
+          }
+          const l = statements.length;
+          try {
+            for (let j = 1; j < l; j++) {
+              const item = statements[j];
+              const c = yield execute(connection, item.query, toArray(item.params));
+              count = count + c;
+            }
+            return count;
           }
-          return [3, 20];
-        case 1:
-          if (!firstSuccess) return [3, 13];
-          _a.label = 2;
-        case 2:
-          _a.trys.push([2, 11, , 12]);
-          return [4, execute(connection, statements[0].query, toArray(statements[0].params))];
-        case 3:
-          count_3 = _a.sent();
-          if (count_3 === 0) {
-            return [2, 0];
+          catch (er1) {
+            throw er1;
           }
-          l = statements.length;
-          _a.label = 4;
-        case 4:
-          _a.trys.push([4, 9, , 10]);
-          j = 1;
-          _a.label = 5;
-        case 5:
-          if (!(j < l)) return [3, 8];
-          item = statements[j];
-          return [4, execute(connection, item.query, toArray(item.params))];
-        case 6:
-          c = _a.sent();
-          count_3 = count_3 + c;
-          _a.label = 7;
-        case 7:
-          j++;
-          return [3, 5];
-        case 8: return [2, count_3];
-        case 9:
-          er1_1 = _a.sent();
-          throw er1_1;
-        case 10: return [3, 12];
-        case 11:
-          er0_1 = _a.sent();
-          throw er0_1;
-        case 12: return [3, 20];
-        case 13:
-          count_4 = 0;
-          l = statements.length;
-          _a.label = 14;
-        case 14:
-          _a.trys.push([14, 19, , 20]);
-          j = 0;
-          _a.label = 15;
-        case 15:
-          if (!(j < l)) return [3, 18];
-          item = statements[j];
-          return [4, execute(connection, item.query, toArray(item.params))];
-        case 16:
-          c = _a.sent();
-          count_4 = count_4 + c;
-          _a.label = 17;
-        case 17:
-          j++;
-          return [3, 15];
-        case 18: return [2, count_4];
-        case 19:
-          err_3 = _a.sent();
-          throw err_3;
-        case 20: return [2];
+        }
+        catch (er0) {
+          throw er0;
+        }
       }
-    });
+      else {
+        let count = 0;
+        const l = statements.length;
+        try {
+          for (let j = 0; j < l; j++) {
+            const item = statements[j];
+            const c = yield execute(connection, item.query, toArray(item.params));
+            count = count + c;
+          }
+          return count;
+        }
+        catch (err) {
+          throw err;
+        }
+      }
+    }
   });
 }
-exports.executeBatchConnection = executeBatchConnection;
 function buildError(err) {
   if (err.errno === 1062 && err.code === "ER_DUP_ENTRY") {
     err.error = "duplicate";
   }
   return err;
 }
-function execute(pool, sql, args) {
-  return __awaiter(this, void 0, void 0, function () {
-    var p;
-    return __generator(this, function (_a) {
-      p = toArray(args);
-      return [2, new Promise(function (resolve, reject) {
-          return pool.execute(sql, p, function (err, res) {
-            if (err) {
-              buildError(err);
-              return reject(err);
-            }
-            else {
-              return resolve(res.affectedRows);
-            }
-          });
-        })];
+export function execute(pool, sql, args) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const p = toArray(args);
+    return new Promise((resolve, reject) => {
+      return pool.execute(sql, p, (err, res) => {
+        if (err) {
+          buildError(err);
+          return reject(err);
+        }
+        else {
+          return resolve(res.affectedRows);
+        }
+      });
     });
   });
 }
-exports.execute = execute;
-function query(pool, sql, args, m, bools) {
-  return __awaiter(this, void 0, void 0, function () {
-    var p;
-    return __generator(this, function (_a) {
-      p = toArray(args);
-      return [2, new Promise(function (resolve, reject) {
-          return pool.query(sql, p, function (err, results, fields) {
-            if (err) {
-              return reject(err);
-            }
-            else {
-              if (results.length > 0) {
-                var arrayResult = results.map(function (item) {
-                  if (Array.isArray(item)) {
-                    return formatData(fields, item);
-                  }
-                  else {
-                    return item;
-                  }
-                });
-                return resolve(handleResults(arrayResult, m, bools));
+export function query(pool, sql, args, m, bools) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const p = toArray(args);
+    return new Promise((resolve, reject) => {
+      return pool.query(sql, p, (err, results, fields) => {
+        if (err) {
+          return reject(err);
+        }
+        else {
+          if (results.length > 0) {
+            const arrayResult = results.map((item) => {
+              if (Array.isArray(item)) {
+                return formatData(fields, item);
               }
               else {
-                resolve([]);
+                return item;
               }
-            }
-          });
-        })];
+            });
+            return resolve(handleResults(arrayResult, m, bools));
+          }
+          else {
+            resolve([]);
+          }
+        }
+      });
     });
   });
 }
-exports.query = query;
-function queryOne(pool, sql, args, m, bools) {
-  return query(pool, sql, args, m, bools).then(function (r) {
+export function queryOne(pool, sql, args, m, bools) {
+  return query(pool, sql, args, m, bools).then((r) => {
     return r && r.length > 0 ? r[0] : null;
   });
 }
-exports.queryOne = queryOne;
-function executeScalar(pool, sql, args) {
-  return queryOne(pool, sql, args).then(function (r) {
+export function executeScalar(pool, sql, args) {
+  return queryOne(pool, sql, args).then((r) => {
     if (!r) {
       return null;
     }
     else {
-      var keys = Object.keys(r);
+      const keys = Object.keys(r);
       return r[keys[0]];
     }
   });
 }
-exports.executeScalar = executeScalar;
-function count(pool, sql, args) {
+export function count(pool, sql, args) {
   return executeScalar(pool, sql, args);
 }
-exports.count = count;
-function save(pool, obj, table, attrs, ver, buildParam) {
-  var s = build_1.buildToSave(obj, table, attrs, ver, buildParam);
+export function save(pool, obj, table, attrs, ver, buildParam) {
+  const s = buildToSave(obj, table, attrs, ver, buildParam);
   if (!s.query) {
     return Promise.resolve(-1);
   }
@@ -723,9 +873,8 @@ function save(pool, obj, table, attrs, ver, buildParam) {
     return execute(pool, s.query, s.params);
   }
 }
-exports.save = save;
-function saveBatch(pool, objs, table, attrs, ver, buildParam) {
-  var s = build_1.buildToSaveBatch(objs, table, attrs, ver, buildParam);
+export function saveBatch(pool, objs, table, attrs, ver, buildParam) {
+  const s = buildToSaveBatch(objs, table, attrs, ver, buildParam);
   if (typeof pool === "function") {
     return pool(s);
   }
@@ -733,14 +882,13 @@ function saveBatch(pool, objs, table, attrs, ver, buildParam) {
     return executeBatch(pool, s);
   }
 }
-exports.saveBatch = saveBatch;
-function toArray(arr) {
+export function toArray(arr) {
   if (!arr || arr.length === 0) {
     return [];
   }
-  var p = [];
-  var l = arr.length;
-  for (var i = 0; i < l; i++) {
+  const p = [];
+  const l = arr.length;
+  for (let i = 0; i < l; i++) {
     if (arr[i] === undefined || arr[i] == null) {
       p.push(null);
     }
@@ -751,7 +899,7 @@ function toArray(arr) {
         }
         else {
           if (resource.string) {
-            var s = JSON.stringify(arr[i]);
+            const s = JSON.stringify(arr[i]);
             p.push(s);
           }
           else {
@@ -766,10 +914,9 @@ function toArray(arr) {
   }
   return p;
 }
-exports.toArray = toArray;
-function handleResults(r, m, bools) {
+export function handleResults(r, m, bools) {
   if (m) {
-    var res = mapArray(r, m);
+    const res = mapArray(r, m);
     if (bools && bools.length > 0) {
       return handleBool(res, bools);
     }
@@ -786,20 +933,17 @@ function handleResults(r, m, bools) {
     }
   }
 }
-exports.handleResults = handleResults;
-function handleBool(objs, bools) {
+export function handleBool(objs, bools) {
   if (!bools || bools.length === 0 || !objs) {
     return objs;
   }
-  for (var _i = 0, objs_1 = objs; _i < objs_1.length; _i++) {
-    var obj = objs_1[_i];
-    var o = obj;
-    for (var _a = 0, bools_1 = bools; _a < bools_1.length; _a++) {
-      var field = bools_1[_a];
+  for (const obj of objs) {
+    const o = obj;
+    for (const field of bools) {
       if (field.name) {
-        var v = o[field.name];
+        const v = o[field.name];
         if (typeof v !== "boolean" && v != null && v !== undefined) {
-          var b = field.true;
+          const b = field.true;
           if (b == null || b === undefined) {
             o[field.name] = "1" == v || "T" == v || "Y" == v || "true" == v || "on" == v;
           }
@@ -812,11 +956,10 @@ function handleBool(objs, bools) {
   }
   return objs;
 }
-exports.handleBool = handleBool;
-function formatData(nameColumn, data, m) {
-  var result = {};
-  nameColumn.forEach(function (item, index) {
-    var key = item.name;
+export function formatData(nameColumn, data, m) {
+  const result = {};
+  nameColumn.forEach((item, index) => {
+    let key = item.name;
     if (m) {
       key = m[item.name];
     }
@@ -824,20 +967,18 @@ function formatData(nameColumn, data, m) {
   });
   return result;
 }
-exports.formatData = formatData;
-function map(obj, m) {
+export function map(obj, m) {
   if (!m) {
     return obj;
   }
-  var mkeys = Object.keys(m);
+  const mkeys = Object.keys(m);
   if (mkeys.length === 0) {
     return obj;
   }
-  var o = {};
-  var keys = Object.keys(obj);
-  for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
-    var key = keys_1[_i];
-    var k0 = m[key];
+  const o = {};
+  const keys = Object.keys(obj);
+  for (const key of keys) {
+    let k0 = m[key];
     if (!k0) {
       k0 = key;
     }
@@ -845,24 +986,22 @@ function map(obj, m) {
   }
   return o;
 }
-exports.map = map;
-function mapArray(results, m) {
+export function mapArray(results, m) {
   if (!m) {
     return results;
   }
-  var mkeys = Object.keys(m);
+  const mkeys = Object.keys(m);
   if (mkeys.length === 0) {
     return results;
   }
-  var objs = [];
-  var length = results.length;
-  for (var i = 0; i < length; i++) {
-    var obj = results[i];
-    var obj2 = {};
-    var keys = Object.keys(obj);
-    for (var _i = 0, keys_2 = keys; _i < keys_2.length; _i++) {
-      var key = keys_2[_i];
-      var k0 = m[key];
+  const objs = [];
+  const length = results.length;
+  for (let i = 0; i < length; i++) {
+    const obj = results[i];
+    const obj2 = {};
+    const keys = Object.keys(obj);
+    for (const key of keys) {
+      let k0 = m[key];
       if (!k0) {
         k0 = key;
       }
@@ -872,15 +1011,13 @@ function mapArray(results, m) {
   }
   return objs;
 }
-exports.mapArray = mapArray;
-function getFields(fields, all) {
+export function getFields(fields, all) {
   if (!fields || fields.length === 0) {
     return undefined;
   }
-  var ext = [];
+  const ext = [];
   if (all) {
-    for (var _i = 0, fields_1 = fields; _i < fields_1.length; _i++) {
-      var s = fields_1[_i];
+    for (const s of fields) {
       if (all.includes(s)) {
         ext.push(s);
       }
@@ -896,9 +1033,8 @@ function getFields(fields, all) {
     return fields;
   }
 }
-exports.getFields = getFields;
-function buildFields(fields, all) {
-  var s = getFields(fields, all);
+export function buildFields(fields, all) {
+  const s = getFields(fields, all);
   if (!s || s.length === 0) {
     return "*";
   }
@@ -906,12 +1042,11 @@ function buildFields(fields, all) {
     return s.join(",");
   }
 }
-exports.buildFields = buildFields;
-function getMapField(name, mp) {
+export function getMapField(name, mp) {
   if (!mp) {
     return name;
   }
-  var x = mp[name];
+  const x = mp[name];
   if (!x) {
     return name;
   }
@@ -920,45 +1055,39 @@ function getMapField(name, mp) {
   }
   return name;
 }
-exports.getMapField = getMapField;
-function isEmpty(s) {
+export function isEmpty(s) {
   return !(s && s.length > 0);
 }
-exports.isEmpty = isEmpty;
-var StringService = (function () {
-  function StringService(pool, table, column) {
+export class StringService {
+  constructor(pool, table, column) {
     this.pool = pool;
     this.table = table;
     this.column = column;
     this.load = this.load.bind(this);
     this.save = this.save.bind(this);
   }
-  StringService.prototype.load = function (key, max) {
-    var _this = this;
-    var s = "select " + this.column + " from " + this.table + " where " + this.column + " like ? order by " + this.column + " limit " + max;
-    return query(this.pool, s, ["" + key + "%"]).then(function (arr) {
-      return arr.map(function (i) { return i[_this.column]; });
+  load(key, max) {
+    const s = `select ${this.column} from ${this.table} where ${this.column} like ? order by ${this.column} limit ${max}`;
+    return query(this.pool, s, ["" + key + "%"]).then((arr) => {
+      return arr.map((i) => i[this.column]);
     });
-  };
-  StringService.prototype.save = function (values) {
+  }
+  save(values) {
     if (!values || values.length === 0) {
       return Promise.resolve(0);
     }
-    var arr = [];
-    for (var i = 1; i <= values.length; i++) {
+    const arr = [];
+    for (let i = 1; i <= values.length; i++) {
       arr.push("(?)");
     }
-    var s = "insert ignore into " + this.table + "(" + this.column + ")values" + arr.join(",");
+    const s = `insert ignore into ${this.table}(${this.column})values${arr.join(",")}`;
     return execute(this.pool, s, values);
-  };
-  return StringService;
-}());
-exports.StringService = StringService;
-function version(attrs) {
-  var ks = Object.keys(attrs);
-  for (var _i = 0, ks_1 = ks; _i < ks_1.length; _i++) {
-    var k = ks_1[_i];
-    var attr = attrs[k];
+  }
+}
+export function version(attrs) {
+  const ks = Object.keys(attrs);
+  for (const k of ks) {
+    const attr = attrs[k];
     if (attr.version) {
       attr.name = k;
       return attr;
@@ -966,9 +1095,8 @@ function version(attrs) {
   }
   return undefined;
 }
-exports.version = version;
-var MySQLWriter = (function () {
-  function MySQLWriter(pool, table, attributes, oneIfSuccess, toDB, buildParam) {
+export class MySQLWriter {
+  constructor(pool, table, attributes, oneIfSuccess, toDB, buildParam) {
     this.table = table;
     this.attributes = attributes;
     this.oneIfSuccess = oneIfSuccess;
@@ -981,24 +1109,24 @@ var MySQLWriter = (function () {
     }
     this.param = buildParam;
     this.map = toDB;
-    var x = version(attributes);
+    const x = version(attributes);
     if (x) {
       this.version = x.name;
     }
   }
-  MySQLWriter.prototype.write = function (obj) {
+  write(obj) {
     if (!obj) {
       return Promise.resolve(0);
     }
-    var obj2 = obj;
+    let obj2 = obj;
     if (this.map) {
       obj2 = this.map(obj);
     }
-    var stmt = build_1.buildToSave(obj2, this.table, this.attributes, this.version, this.param);
+    const stmt = buildToSave(obj2, this.table, this.attributes, this.version, this.param);
     if (stmt.query) {
       if (this.execute) {
         if (this.oneIfSuccess) {
-          return this.execute(stmt.query, stmt.params).then(function (ct) { return (ct > 0 ? 1 : 0); });
+          return this.execute(stmt.query, stmt.params).then((ct) => (ct > 0 ? 1 : 0));
         }
         else {
           return this.execute(stmt.query, stmt.params);
@@ -1006,7 +1134,7 @@ var MySQLWriter = (function () {
       }
       else {
         if (this.oneIfSuccess) {
-          return execute(this.pool, stmt.query, stmt.params).then(function (ct) { return (ct > 0 ? 1 : 0); });
+          return execute(this.pool, stmt.query, stmt.params).then((ct) => (ct > 0 ? 1 : 0));
         }
         else {
           return execute(this.pool, stmt.query, stmt.params);
@@ -1016,12 +1144,10 @@ var MySQLWriter = (function () {
     else {
       return Promise.resolve(0);
     }
-  };
-  return MySQLWriter;
-}());
-exports.MySQLWriter = MySQLWriter;
-var MySQLStreamWriter = (function () {
-  function MySQLStreamWriter(pool, table, attributes, size, toDB, buildParam) {
+  }
+}
+export class MySQLStreamWriter {
+  constructor(pool, table, attributes, size, toDB, buildParam) {
     this.table = table;
     this.attributes = attributes;
     this.list = [];
@@ -1036,7 +1162,7 @@ var MySQLStreamWriter = (function () {
     }
     this.param = buildParam;
     this.map = toDB;
-    var x = version(attributes);
+    const x = version(attributes);
     if (x) {
       this.version = x.name;
     }
@@ -1044,11 +1170,11 @@ var MySQLStreamWriter = (function () {
       this.size = size;
     }
   }
-  MySQLStreamWriter.prototype.write = function (obj) {
+  write(obj) {
     if (!obj) {
       return Promise.resolve(0);
     }
-    var obj2 = obj;
+    let obj2 = obj;
     if (this.map) {
       obj2 = this.map(obj);
       this.list.push(obj2);
@@ -1062,26 +1188,25 @@ var MySQLStreamWriter = (function () {
     else {
       return this.flush();
     }
-  };
-  MySQLStreamWriter.prototype.flush = function () {
-    var _this = this;
+  }
+  flush() {
     if (!this.list || this.list.length === 0) {
       return Promise.resolve(0);
     }
     else {
-      var total_1 = this.list.length;
-      var stmt = build_1.buildToSaveBatch(this.list, this.table, this.attributes, this.version, this.param);
+      const total = this.list.length;
+      const stmt = buildToSaveBatch(this.list, this.table, this.attributes, this.version, this.param);
       if (stmt.length > 0) {
         if (this.executeBatch) {
-          return this.executeBatch(stmt).then(function (r) {
-            _this.list = [];
-            return total_1;
+          return this.executeBatch(stmt).then((r) => {
+            this.list = [];
+            return total;
           });
         }
         else {
-          return executeBatch(this.pool, stmt).then(function (r) {
-            _this.list = [];
-            return total_1;
+          return executeBatch(this.pool, stmt).then((r) => {
+            this.list = [];
+            return total;
           });
         }
       }
@@ -1089,12 +1214,10 @@ var MySQLStreamWriter = (function () {
         return Promise.resolve(0);
       }
     }
-  };
-  return MySQLStreamWriter;
-}());
-exports.MySQLStreamWriter = MySQLStreamWriter;
-var MySQLBatchWriter = (function () {
-  function MySQLBatchWriter(pool, table, attributes, oneIfSuccess, toDB, buildParam) {
+  }
+}
+export class MySQLBatchWriter {
+  constructor(pool, table, attributes, oneIfSuccess, toDB, buildParam) {
     this.table = table;
     this.attributes = attributes;
     this.oneIfSuccess = oneIfSuccess;
@@ -1107,29 +1230,28 @@ var MySQLBatchWriter = (function () {
     }
     this.param = buildParam;
     this.map = toDB;
-    var x = version(attributes);
+    const x = version(attributes);
     if (x) {
       this.version = x.name;
     }
   }
-  MySQLBatchWriter.prototype.write = function (objs) {
+  write(objs) {
     if (!objs || objs.length === 0) {
       return Promise.resolve(0);
     }
-    var list = objs;
+    let list = objs;
     if (this.map) {
       list = [];
-      for (var _i = 0, objs_2 = objs; _i < objs_2.length; _i++) {
-        var obj = objs_2[_i];
-        var obj2 = this.map(obj);
+      for (const obj of objs) {
+        const obj2 = this.map(obj);
         list.push(obj2);
       }
     }
-    var stmts = build_1.buildToSaveBatch(list, this.table, this.attributes, this.version, this.param);
+    const stmts = buildToSaveBatch(list, this.table, this.attributes, this.version, this.param);
     if (stmts.length > 0) {
       if (this.execute) {
         if (this.oneIfSuccess) {
-          return this.execute(stmts).then(function (ct) { return stmts.length; });
+          return this.execute(stmts).then((ct) => stmts.length);
         }
         else {
           return this.execute(stmts);
@@ -1137,7 +1259,7 @@ var MySQLBatchWriter = (function () {
       }
       else {
         if (this.oneIfSuccess) {
-          return executeBatch(this.pool, stmts).then(function (ct) { return stmts.length; });
+          return executeBatch(this.pool, stmts).then((ct) => stmts.length);
         }
         else {
           return executeBatch(this.pool, stmts);
@@ -1147,12 +1269,10 @@ var MySQLBatchWriter = (function () {
     else {
       return Promise.resolve(0);
     }
-  };
-  return MySQLBatchWriter;
-}());
-exports.MySQLBatchWriter = MySQLBatchWriter;
-var MySQLChecker = (function () {
-  function MySQLChecker(pool, service, timeout) {
+  }
+}
+export class MySQLChecker {
+  constructor(pool, service, timeout) {
     this.pool = pool;
     this.timeout = timeout ? timeout : 4200;
     this.service = service ? service : "mysql";
@@ -1160,36 +1280,31 @@ var MySQLChecker = (function () {
     this.name = this.name.bind(this);
     this.build = this.build.bind(this);
   }
-  MySQLChecker.prototype.check = function () {
-    return __awaiter(this, void 0, void 0, function () {
-      var obj, promise;
-      var _this = this;
-      return __generator(this, function (_a) {
-        obj = {};
-        promise = new Promise(function (resolve, reject) {
-          _this.pool.query("select current_time", function (err, result) {
-            if (err) {
-              return reject(err);
-            }
-            else {
-              resolve(obj);
-            }
-          });
+  check() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const obj = {};
+      const promise = new Promise((resolve, reject) => {
+        this.pool.query("select current_time", (err, result) => {
+          if (err) {
+            return reject(err);
+          }
+          else {
+            resolve(obj);
+          }
         });
-        if (this.timeout > 0) {
-          return [2, promiseTimeOut(this.timeout, promise)];
-        }
-        else {
-          return [2, promise];
-        }
-        return [2];
       });
+      if (this.timeout > 0) {
+        return promiseTimeOut(this.timeout, promise);
+      }
+      else {
+        return promise;
+      }
     });
-  };
-  MySQLChecker.prototype.name = function () {
+  }
+  name() {
     return this.service;
-  };
-  MySQLChecker.prototype.build = function (data, err) {
+  }
+  build(data, err) {
     if (err) {
       if (!data) {
         data = {};
@@ -1197,22 +1312,20 @@ var MySQLChecker = (function () {
       data["error"] = err;
     }
     return data;
-  };
-  return MySQLChecker;
-}());
-exports.MySQLChecker = MySQLChecker;
+  }
+}
 function promiseTimeOut(timeoutInMilliseconds, promise) {
   return Promise.race([
     promise,
-    new Promise(function (resolve, reject) {
-      setTimeout(function () {
-        reject("Timed out in: " + timeoutInMilliseconds + " milliseconds!");
+    new Promise((resolve, reject) => {
+      setTimeout(() => {
+        reject(`Timed out in: ${timeoutInMilliseconds} milliseconds!`);
       }, timeoutInMilliseconds);
     }),
   ]);
 }
-var Exporter = (function () {
-  function Exporter(connection, buildQuery, ft, write, end, attributes) {
+export class Exporter {
+  constructor(connection, buildQuery, ft, write, end, attributes) {
     this.connection = connection;
     this.buildQuery = buildQuery;
     this.write = write;
@@ -1224,73 +1337,55 @@ var Exporter = (function () {
     }
     this.export = this.export.bind(this);
   }
-  Exporter.prototype.export = function (ctx) {
-    return __awaiter(this, void 0, void 0, function () {
-      var idx, stmt, reader, er;
-      var _this = this;
-      return __generator(this, function (_a) {
-        switch (_a.label) {
-          case 0:
-            idx = 0;
-            return [4, this.buildQuery(ctx)];
-          case 1:
-            stmt = _a.sent();
-            reader = this.connection.query(stmt.query, stmt.params);
-            reader.on("error", function (err) { return (er = err); });
-            if (this.map) {
-              reader.on("result", function (row) { return __awaiter(_this, void 0, void 0, function () {
-                var obj, data;
-                return __generator(this, function (_a) {
-                  ++idx;
-                  this.connection.pause();
-                  obj = mapOne(row, this.map);
-                  data = this.format(obj);
-                  this.write(data);
-                  this.connection.resume();
-                  return [2];
-                });
-              }); });
-            }
-            else {
-              reader.on("result", function (row) { return __awaiter(_this, void 0, void 0, function () {
-                var data;
-                return __generator(this, function (_a) {
-                  ++idx;
-                  this.connection.pause();
-                  data = this.format(row);
-                  this.write(data);
-                  this.connection.resume();
-                  return [2];
-                });
-              }); });
-            }
-            return [2, new Promise(function (resolve, reject) {
-                reader.on("end", function () {
-                  _this.end();
-                  if (er) {
-                    reject(er);
-                  }
-                  else {
-                    _this.connection.end(function (err) {
-                      if (err) {
-                        reject(err);
-                      }
-                      else {
-                        resolve(idx);
-                      }
-                    });
-                  }
-                });
-              })];
-        }
+  export(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+      let idx = 0;
+      const stmt = yield this.buildQuery(ctx);
+      const reader = this.connection.query(stmt.query, stmt.params);
+      let er;
+      reader.on("error", (err) => (er = err));
+      if (this.map) {
+        reader.on("result", (row) => __awaiter(this, void 0, void 0, function* () {
+          ++idx;
+          this.connection.pause();
+          const obj = mapOne(row, this.map);
+          const data = this.format(obj);
+          this.write(data);
+          this.connection.resume();
+        }));
+      }
+      else {
+        reader.on("result", (row) => __awaiter(this, void 0, void 0, function* () {
+          ++idx;
+          this.connection.pause();
+          const data = this.format(row);
+          this.write(data);
+          this.connection.resume();
+        }));
+      }
+      return new Promise((resolve, reject) => {
+        reader.on("end", () => {
+          this.end();
+          if (er) {
+            reject(er);
+          }
+          else {
+            this.connection.end((err) => {
+              if (err) {
+                reject(err);
+              }
+              else {
+                resolve(idx);
+              }
+            });
+          }
+        });
       });
     });
-  };
-  return Exporter;
-}());
-exports.Exporter = Exporter;
-var ExportService = (function () {
-  function ExportService(connection, queryBuilder, formatter, writer, attributes) {
+  }
+}
+export class ExportService {
+  constructor(connection, queryBuilder, formatter, writer, attributes) {
     this.connection = connection;
     this.queryBuilder = queryBuilder;
     this.formatter = formatter;
@@ -1301,90 +1396,71 @@ var ExportService = (function () {
     }
     this.export = this.export.bind(this);
   }
-  ExportService.prototype.export = function (ctx) {
-    return __awaiter(this, void 0, void 0, function () {
-      var idx, stmt, reader, er;
-      var _this = this;
-      return __generator(this, function (_a) {
-        switch (_a.label) {
-          case 0:
-            idx = 0;
-            return [4, this.queryBuilder.build(ctx)];
-          case 1:
-            stmt = _a.sent();
-            reader = this.connection.query(stmt.query, stmt.params);
-            reader.on("error", function (err) { return (er = err); });
-            if (this.map) {
-              reader.on("result", function (row) { return __awaiter(_this, void 0, void 0, function () {
-                var obj, data;
-                return __generator(this, function (_a) {
-                  ++idx;
-                  this.connection.pause();
-                  obj = mapOne(row, this.map);
-                  data = this.formatter.format(obj);
-                  this.writer.write(data);
-                  this.connection.resume();
-                  return [2];
-                });
-              }); });
-            }
-            else {
-              reader.on("result", function (row) { return __awaiter(_this, void 0, void 0, function () {
-                var data;
-                return __generator(this, function (_a) {
-                  ++idx;
-                  this.connection.pause();
-                  data = this.formatter.format(row);
-                  this.writer.write(data);
-                  this.connection.resume();
-                  return [2];
-                });
-              }); });
-            }
-            return [2, new Promise(function (resolve, reject) {
-                reader.on("end", function () {
-                  if (_this.writer.end) {
-                    _this.writer.end();
-                  }
-                  else if (_this.writer.flush) {
-                    _this.writer.flush();
-                  }
-                  if (er) {
-                    reject(er);
-                  }
-                  else {
-                    _this.connection.end(function (err) {
-                      if (err) {
-                        reject(err);
-                      }
-                      else {
-                        resolve(idx);
-                      }
-                    });
-                  }
-                });
-              })];
-        }
+  export(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+      let idx = 0;
+      const stmt = yield this.queryBuilder.build(ctx);
+      const reader = this.connection.query(stmt.query, stmt.params);
+      let er;
+      reader.on("error", (err) => (er = err));
+      if (this.map) {
+        reader.on("result", (row) => __awaiter(this, void 0, void 0, function* () {
+          ++idx;
+          this.connection.pause();
+          const obj = mapOne(row, this.map);
+          const data = this.formatter.format(obj);
+          this.writer.write(data);
+          this.connection.resume();
+        }));
+      }
+      else {
+        reader.on("result", (row) => __awaiter(this, void 0, void 0, function* () {
+          ++idx;
+          this.connection.pause();
+          const data = this.formatter.format(row);
+          this.writer.write(data);
+          this.connection.resume();
+        }));
+      }
+      return new Promise((resolve, reject) => {
+        reader.on("end", () => {
+          if (this.writer.end) {
+            this.writer.end();
+          }
+          else if (this.writer.flush) {
+            this.writer.flush();
+          }
+          if (er) {
+            reject(er);
+          }
+          else {
+            this.connection.end((err) => {
+              if (err) {
+                reject(err);
+              }
+              else {
+                resolve(idx);
+              }
+            });
+          }
+        });
       });
     });
-  };
-  return ExportService;
-}());
-exports.ExportService = ExportService;
-function mapOne(results, m) {
-  var obj = results;
+  }
+}
+export function mapOne(results, m) {
+  const obj = results;
   if (!m) {
     return obj;
   }
-  var mkeys = Object.keys(m);
+  const mkeys = Object.keys(m);
   if (mkeys.length === 0) {
     return obj;
   }
-  var obj2 = {};
-  var keys = Object.keys(obj);
-  for (var _i = 0, keys_3 = keys; _i < keys_3.length; _i++) {
-    var key = keys_3[_i];
-    var k0 = m[key];
+  const obj2 = {};
+  const keys = Object.keys(obj);
+  for (const key of keys) {
+    let k0 = m[key];
     if (!k0) {
       k0 = key;
     }
@@ -1392,17 +1468,15 @@ function mapOne(results, m) {
   }
   return obj2;
 }
-exports.mapOne = mapOne;
-function buildMap(attrs) {
-  var mp = {};
-  var ks = Object.keys(attrs);
-  var isMap = false;
-  for (var _i = 0, ks_2 = ks; _i < ks_2.length; _i++) {
-    var k = ks_2[_i];
-    var attr = attrs[k];
+export function buildMap(attrs) {
+  const mp = {};
+  const ks = Object.keys(attrs);
+  let isMap = false;
+  for (const k of ks) {
+    const attr = attrs[k];
     attr.name = k;
-    var field = attr.column ? attr.column : k;
-    var s = field.toLowerCase();
+    const field = attr.column ? attr.column : k;
+    const s = field.toLowerCase();
     if (s !== k) {
       mp[s] = k;
       isMap = true;
@@ -1413,17 +1487,14 @@ function buildMap(attrs) {
   }
   return undefined;
 }
-exports.buildMap = buildMap;
-function select(table, attrs) {
-  var cols = [];
-  var ks = Object.keys(attrs);
-  for (var _i = 0, ks_3 = ks; _i < ks_3.length; _i++) {
-    var k = ks_3[_i];
-    var attr = attrs[k];
+export function select(table, attrs) {
+  const cols = [];
+  const ks = Object.keys(attrs);
+  for (const k of ks) {
+    const attr = attrs[k];
     attr.name = k;
-    var field = attr.column ? attr.column : k;
+    const field = attr.column ? attr.column : k;
     cols.push(field);
   }
-  return "select " + cols.join(",") + " from " + table;
+  return `select ${cols.join(",")} from ${table}`;
 }
-exports.select = select;