dborm-mysql 2.2.1 → 2.2.3

package/base/db.js

@@ -11,16 +11,16 @@ function initMysqlPool(db, dbConfig) {
     db.pool = mysql.createPool(dbConfig);
 }
 
-let logSql = (connection, rows, sql, startTime, logExecuteTime) => {
+let logSql = (connection, rows, sql, startTime, logExecuteTime, logger) => {
     let insertIdLog = (rows && rows.insertId) ? `[insertId = ${rows.insertId}] ` : '';
 
     let info = `[${connection.connectionLogId}] [${moment().format('YYYY-MM-DD HH:mm:ss.mm.SSS')}]`;
     if(logExecuteTime){
         const executeTime = (new Date()).getTime() - startTime.getTime();
-        info += `[execute time: ${executeTime}ms]`
+        info += `[execute time: ${executeTime}ms]`;
     }
     info += `${insertIdLog} ${sql}`;
-    console.log(info);
+    logger(info);
 };
 
 // 去掉报错信息行，只保留当前函数调用栈
@@ -29,32 +29,33 @@ let getCurrentStack = (currentStack) => {
     return currentStack.split('\n').slice(1).join('\n');
 };
 
-module.exports = (dbConfig, {log, noConvertDbCodes, dbCode, logExecuteTime}) => {
+module.exports = (dbConfig, {log, noConvertDbCodes, dbCode, logExecuteTime, logger}) => {
     let db = {
         pool: null
     };
     initMysqlPool(db, dbConfig);
     let reconnectionTime = 0;
     //获取数据连接，将回调转换为promise
-    db.getConnection = function () {
+    db.getConnection = function (options = {}) {
         return new Promise(function (resolve, reject) {
             db.pool.getConnection(function (err, connection) {
                 if (err) {
                     if(err.code === 'ECONNREFUSED' || err.code === 'ETIMEDOUT' || err.code === 'PROTOCOL_SEQUENCE_TIMEOUT'){
-                        console.log('mysql reconnect， reconnect time:', reconnectionTime++);
+                        logger('mysql reconnect， reconnect time:', reconnectionTime++);
                         db.getConnection().then(resolve, reject);
                     }
                     reject(err);
                 } else {
-                    connection.connectionLogId = shortUuid().new().slice(0, 6);
+                    connection.connectionLogId = options.transId || shortUuid().new().slice(0, 6);
                     reconnectionTime = 0;
+                    connection.logSql = options.transId || options.logSql || log || process.SQL_LOG;
                     resolve(connection);
                 }
             });
         });
     };
 
-    db.wrapTransaction = function (fn, nth, timeout) {
+    db.wrapTransaction = function (fn, nth, timeout, options = {}) {
         const Message = '等待事务超时';
         return function () {
             let ctx = this;
@@ -63,24 +64,35 @@ module.exports = (dbConfig, {log, noConvertDbCodes, dbCode, logExecuteTime}) =>
                 return fn.apply(ctx, params);
             } else {
                 return (co.wrap(function* (params) {
-                    let conn = yield db.beginTransaction();
+                    let newOptions = Object.assign({}, options);
+                    if (options.transId && typeof options.transId === 'function'){
+                        newOptions.transId = options.transId(params);
+                    }
+                    if (options.logSql && typeof options.logSql === 'function'){
+                        newOptions.logSql = options.logSql(params);
+                    }
+
+                    let conn = yield db.beginTransaction(newOptions);
                     let result;
+                    let timer;
                     try {
                         params[nth] = conn;
                         result = yield Promise.race([
                             fn.apply(ctx, params),
                             new Promise((res) => {
-                                setTimeout(() => {
+                                timer = setTimeout(() => {
                                     res(Message);
                                 }, timeout || 50000);
                             })
                         ]);
+                        if(timer) clearTimeout(timer);
                         if(result === Message){
                             throw new Error(result);
                         }
                         yield db.commitTransaction(conn);
                         conn.release();
                     } catch (err) {
+                        if(timer) clearTimeout(timer);
                         yield db.rollbackTransaction(conn);
                         conn.release();
                         conn.destroy();
@@ -110,12 +122,12 @@ module.exports = (dbConfig, {log, noConvertDbCodes, dbCode, logExecuteTime}) =>
 
             if (connection) {
                 query = connection.query(sql, sqlParam, function (err, rows) {
-                    if(log || process.SQL_LOG){
-                        logSql(connection, rows, query.sql, startTime, logExecuteTime);
+                    if(connection.logSql){
+                        logSql(connection, rows, query.sql, startTime, logExecuteTime, logger);
                     }
                     if (err) {
-                        if(!log&&!process.SQL_LOG){
-                            logSql(connection, rows, query.sql, startTime, logExecuteTime);
+                        if (!connection.logSql){
+                            logSql(connection, rows, query.sql, startTime, logExecuteTime, logger);
                         }
                         err.code = dbCode;
                         err.stack = err.stack + getCurrentStack(currentStack);
@@ -127,13 +139,13 @@ module.exports = (dbConfig, {log, noConvertDbCodes, dbCode, logExecuteTime}) =>
             } else {
                 db.getConnection().then(function (connection) {
                     query = connection.query(sql, sqlParam, function (err, rows) {
-                        if(log || process.SQL_LOG){
-                            logSql(connection, rows, query.sql, startTime, logExecuteTime);
+                        if(connection.logSql){
+                            logSql(connection, rows, query.sql, startTime, logExecuteTime, logger);
                         }
                         connection.release();
                         if (err) {
-                            if(!log&&!process.SQL_LOG){
-                                logSql(connection, rows, query.sql, startTime, logExecuteTime);
+                            if (!connection.logSql){
+                                logSql(connection, rows, query.sql, startTime, logExecuteTime, logger);
                             }
                             connection.destroy();
                             err.code = dbCode;
@@ -150,11 +162,11 @@ module.exports = (dbConfig, {log, noConvertDbCodes, dbCode, logExecuteTime}) =>
         });
     };
 
-    db.beginTransaction = function () {
+    db.beginTransaction = function (options) {
         let p = new Promise(function (resolve, reject) {
-            db.getConnection().then(function (conn) {
-                if(log || process.SQL_LOG){
-                    console.log(`[${conn.connectionLogId}] [${moment().format('YYYY-MM-DD HH:mm:ss.mm.SSS')}] beginTransaction`);
+            db.getConnection(options).then(function (conn) {
+                if(conn.logSql){
+                    logger(`[${conn.connectionLogId}] [${moment().format('YYYY-MM-DD HH:mm:ss.mm.SSS')}] beginTransaction`);
                 }
                 conn.beginTransaction(function (err) {
                     if (err) {
@@ -178,8 +190,8 @@ module.exports = (dbConfig, {log, noConvertDbCodes, dbCode, logExecuteTime}) =>
                 if (err) {
                     reject(err);
                 } else {
-                    if(log || process.SQL_LOG){
-                        console.log(`[${conn.connectionLogId}] [${moment().format('YYYY-MM-DD HH:mm:ss.mm.SSS')}] commitTransaction`);
+                    if(conn.logSql){
+                        logger(`[${conn.connectionLogId}] [${moment().format('YYYY-MM-DD HH:mm:ss.mm.SSS')}] commitTransaction`);
                     }
                     // conn.release();
                     resolve('success');
@@ -191,8 +203,8 @@ module.exports = (dbConfig, {log, noConvertDbCodes, dbCode, logExecuteTime}) =>
     db.rollbackTransaction = function (conn) {
         return new Promise(function (resolve, reject) {
             conn.rollback(function (err, suc) {
-                if(log || process.SQL_LOG){
-                    console.log(`[${conn.connectionLogId}] [${moment().format('YYYY-MM-DD HH:mm:ss.mm.SSS')}] rollbackTransaction`);
+                if(conn.logSql){
+                    logger(`[${conn.connectionLogId}] [${moment().format('YYYY-MM-DD HH:mm:ss.mm.SSS')}] rollbackTransaction`);
                 }
                 resolve();
             });
@@ -200,5 +212,4 @@ module.exports = (dbConfig, {log, noConvertDbCodes, dbCode, logExecuteTime}) =>
     };
 
     return db;
-};
-
+};

package/base/dbORM.js

@@ -10,6 +10,7 @@ let dbFunss = (config) => {
     let exportsObj = {};
     let db = dbOrigin(dbConfig, {
         log: options.log || log,
+        logger: options.logger || console.log,
         noConvertDbCodes,
         dbCode,
         logExecuteTime //打印 sql 执行时间，默认开启

package/index.d.ts

@@ -51,6 +51,7 @@ interface options {
     dbCode: number;
     noConvertDbCodes: Array<number>,
     logExecuteTime?: boolean,
+    logger?: any; 
 }
 
 
@@ -76,7 +77,7 @@ declare namespace dbORM {
     interface ORM_DB {
         pool: mysql.Pool,
         getConnection(): Promise<mysql.Connection>,
-        wrapTransaction(fn: Function, nth: number, timeout?: number): (...args: any[]) => Promise<any>,
+        wrapTransaction(fn: Function, nth: number, timeout?: number, options?: {transId?: any, logSql?: any}): (...args: any[]) => Promise<any>,
         query(sql: string, params: Array<any>, connection?: mysql.Connection): Promise<any>,
         beginTransaction(): Promise<mysql.Connection>,
         commitTransaction(conn: mysql.Connection): Promise<any>,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dborm-mysql",
-  "version": "2.2.1",
+  "version": "2.2.3",
   "description": "a NodeJs ORM for mysql",
   "main": "index.js",
   "types": "index.d.ts",