Javascript 我如何才能正确地为NodeJ推荐这两种数据库方法？

我有一个处理连接设置和池的数据库模块，还有一个依赖数据库模块执行查询的查询模块。我正在对它们进行调整，以使用异步调用的承诺。到目前为止，我希望转换数据库模块

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

以下是我迄今为止所做的工作：

---

数据库模块

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

    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);
    }

查询模块这应该

然后

在

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()
                    });
                }
            });
        });
    },

---

数据库模块

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

    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);
    }

查询模块

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

    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);
    }

getConnection

应返回[连接的]承诺

相反，它应该使用，并调用

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;
    });
}

---

我不知道你为什么要求我们用问答的形式来解决你的问题，但我不喜欢这种问题。正如我之前所说，作为一名promise粉丝和bluebird撰稿人，我不介意在适当的支持渠道中询问您的问题，但这个问题不会教给其他用户任何东西。如果您在这里对前面的问题进行清晰的总结，并强调您真正想做的事情，那会更好。这里的问题在哪里？如果这是一个规范的问题，你可能想选择一些规范的问题来回答。请在这个问题上添加一个问题。我在这里对你的意图进行了疯狂的猜测；请检查编辑。这将失败，因为第一个链中的上下文（以及其他一些东西），但我也不明白你为什么要首先帮助解决这类问题。我喜欢

getConnection

@user2727195你在使用库吗？@BenjaminGruenbaum不使用任何库，本机JavaScript仅承诺。@Bergi承诺构造函数执行器回调函数中的

this.pool

是什么？（什么是

this

？）此答案没有任何关于更改内容、更改方式或更改原因的解释。

this.queryRequest=queryRequest

，

self.resolve=resolve和
自我拒绝=拒绝
似乎是一个非常糟糕的主意，因为它不允许并发请求。此外，您似乎正在使用in-in-your
execute
方法（隐藏在
result
和
fault
中）来处理并发请求，每个方法都有一个新的
QueryModule
实例化request@user2727195字体但你为什么要这样做？与其使用
QueryModule
类，用户可能会在同一实例上多次错误调用
.execute
，不如只公开一个简单的
query
函数。