如何为nodejs正确promisify这两种数据库方法？

Question

我有一个处理连接设置和池的数据库模块，以及一个依赖数据库模块来执行查询的查询模块。 我正在调整它们以将 Promise 用于异步调用。 到目前为止， 我已经调整了查询​​模块- 现在我希望转换数据库模块。

问题是：数据库模块应该可以直接和隐式地被查询模块（目前依赖于回调）使用。 我怎样才能在两个模块的方法中使用 promises 而不会把它变成一个曲折的小段落的迷宫？

这是我到目前为止所做的：

数据库模块

getConnection: function(callback) { //this should return a promise
    this.pool.getConnection(function(error, connection){
        callback(error, connection);
    });
},

查询模块这应该then在getConnection承诺，执行查询，然后拒绝/决心为它的调用者

    request: function(queryRequest) {
        return new Promise(function(resolve, reject){
            Database.getConnection(function(error, connection){
                if(error) {
                    reject({error: error, queryRequest: queryRequest});
                } else {
                    connection.query(queryRequest.sql, queryRequest.values, function(error, rows, fields){
                        if(error) {
                            reject({error: error, queryRequest: queryRequest});
                        } else {
                            resolve({rows: rows, fields: fields, queryRequest: queryRequest});
                        }
                        connection.release()
                    });
                }
            });
        });
    },

Answer 1

getConnection应该返回一个承诺 [对于连接]

而不是，它应该使用disposer 模式，并调用connection.release()本身：

function withConnection(callback) {
    var pool = this.pool;
    var conn = new Promise(function(resolve, reject) {
        pool.getConnection(function(error, connection){
            if (error)
                reject(error);
            else
                resolve(connection);
        });
    });
    return conn.then(function(connection) {
        var res = conn.then(callback); // safe call
        return res.then(fin); // `finally` shim
        function fin() {
            connection.release();
            return res;
        }
    });
}

function request(queryRequest) {
    return Database.withConnection(function(connection) {
        return new Promise(function(resolve, reject) {
            connection.query(queryRequest.sql, queryRequest.values, function(error, rows, fields) {
                if (error)
                    reject(error);
                else
                    resolve({rows: rows, fields: fields, queryRequest: queryRequest});
            });
        });
    }).catch(function(error) {
        error.queryRequest = queryRequest;
        throw error;
    });
}

Answer 2

数据库模块

    getConnection: function() {
        return new Promise(function(resolve, reject) {
            this.pool.getConnection(function(error, connection){
                if(error) {
                    reject(error);
                } else {
                    resolve(connection);
                }
            });
        });
    },

查询模块

    execute: function(queryRequest) {
        var self = this;
        this.queryRequest = queryRequest;

        return new Promise(function(resolve, reject) {
            self.resolve = resolve;
            self.reject = reject;
            var promise = Database.getConnection();
            promise.then(self.result.bind(self), self.fault.bind(self));
        });
    },

    result: function(connection) {
        var self = this;
        connection.query(this.queryRequest.sql, this.queryRequest.values, function(error, rows, fields) {
            if (error) {
                self.reject(error);
            } else {
                self.resolve({rows: rows, fields: fields, queryRequest: self.queryRequest});
            }
            connection.release();
        });
    },

    fault: function(info) {
        self.reject(info);
    }