Javascript Node.js、RESTIFY、Mongoose、Promise：试图$push一个数组进行更新，但不起作用

我之所以使用这种方法，是因为我存储了一系列机密消息，我想生动地理解它为什么不更新

下面是db.js：

const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const ObjectId = mongoose.Types.ObjectId;

const usersessionSchema = new Schema({
  fb_id: String,
  fb_name: String,
  fb_profpic: String,
  message_body: [
    {
      message: String,
      message_type: String,
      timestamp: String
    }
  ],
  admin: Boolean,
  branch: String
});

const model = (prefix) => {
    prefix = prefix || '';
    console.log(prefix);
    if (prefix.length > 0) {
        return mongoose.model(prefix + "-usersessions", usersessionSchema);
    } else {
        return new Error('Undefined collection prefix!');
    }
}
/** Push message into message body*/
    module.exports.pushsession =
        async(model, id, data) => {
            return new Promise((resolve, reject) => {
                console.log(data);
                model.findOneAndUpdate({fb_id: id}, {$push: {data}},{safe: true})
                    .then(res => {
                        console.log(res);
                        /
                        resolve(res);
                    })
                    .catch(err => {
                        reject(err);
                        console.log(err);
                        throw err;
                    });
        });
    }

const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const ObjectId = mongoose.Types.ObjectId;

const usersessionSchema = new Schema({
  fb_id: String,
  fb_name: String,
  fb_profpic: String,
  message_body:[{
      message: String,
      message_type: String,
      timestamp: String
  }],
  admin: Boolean,
  branch: String
});
/** Push message into message body*/
module.exports.pushsession =
async(model, id, data) => {
    console.log(data);
    return new Promise((resolve, reject) => {
        model.findOneAndUpdate({fb_id: id}, { $push: { message_body: data }})
        .then(res => {
            console.log(res);
            resolve(res);
        })
        .catch(err => {
            reject(err);
            console.log(err);
            throw err;
        });
    });
}

以下是controller.js：

/** Push usersession message  */
module.exports.pushsession =
    async(req, res, next) => {
        try {
            //jwt.validateToken(req);
            var en = "en";
            var dateEn = moment().locale(en);

            format = "MM/DD/YYYY h:mm:ss A"; //h:mm:ss.SSS if you want miliseconds

            var datetime_now = dateEn.format(format);

            console.log(datetime_now);

            var request = {

                    message_body: {
                        message: req.body.message,
                        message_type: req.body.message_type,
                        timestamp: datetime_now
                    }
            };

            const model = usersessionDB(req.query['client']);
            const id = req.body.fb_id;
            const result = await usersessionDB.pushsession(model, id, request);
            if (result) {
                response.success(res, next, result, 200, response.HTTP_STATUS_CODES.ok);
            } else {
                response.failure(res, next, {
                    message: 'ID does not exist'
                }, 404, response.HTTP_STATUS_CODES.not_found);
            }
        } catch (err) {
            response.failure(res, next, err, 500, response.HTTP_STATUS_CODES.internal_server_error);
        }
    }

/** Push usersession message  */
module.exports.pushsession =
   async (req, res, next) => {
        try {
            //jwt.validateToken(req);
            var en = "en";
            var dateEn = moment().locale(en);

            format = "MM/DD/YYYY h:mm:ss A"; //h:mm:ss.SSS if you want miliseconds

            var datetime_now = dateEn.format(format);

            console.log(datetime_now);

            var data = { 

                    message: req.body.message, 
                    message_type: req.body.message_type,
                    timestamp: datetime_now

            };


            const model = usersessionDB(req.query['client']);
            const id = req.body.fb_id;
            console.log(id);
            const result = await usersessionDB.pushsession(model, id, data).then(
                (result) => { // when resolved
                    response.success(res, next, result, 200, response.HTTP_STATUS_CODES.ok);
                }, 
                (err) => { // when rejected
                    response.failure(res, next, {
                                message: 'ID does not exist'
                            }, 404, response.HTTP_STATUS_CODES.not_found);
                });
        } catch (err) {
            response.failure(res, next, err, 500, response.HTTP_STATUS_CODES.internal_server_error);
        }
    }

下面是route.js：

const controller = require('../controller/usersession-controller');

module.exports =
    (server) => {
        server.post('/api/session', controller.create);
        server.get('/api/session', controller.list);
        server.get('/api/session/:id', controller.get);
        server.put('/api/session/:id', controller.update);
        server.del('/api/session/:id', controller.delete);
        server.put('/api/pushsession', controller.pushsession);
    }

从视觉上看，如果您使用postman运行此程序，您可以看到它显示了我要搜索和更新的内容

我想要做的是在消息体中插入另一组数组

这段代码在没有承诺的情况下运行，但在我的项目中它是必需的，因此我无法删除它。

因此，基于：

这段代码在没有承诺的情况下运行

我可以指出一两件事

在db.js中

 module.exports.pushsession =
        async(model, id, data) => {
            return new Promise((resolve, reject) => {

您不需要

async

，因为您返回的是

promise

，所以请替换它

async（模型、id、数据）=>{

与

（型号、id、数据）=>{

由于您返回了一个

承诺

并删除了

异步

，因此不需要另一端的

等待（controller.js），因此

 const result = await usersessionDB.pushsession(model, id, request);
            if (result) {
                response.success(res, next, result, 200, response.HTTP_STATUS_CODES.ok);
            } else {

应该是

usersessionDB.pushsession(model, id, request).then(
    (result) => { // when resolved
        response.success(res, next, result, 200, response.HTTP_STATUS_CODES.ok);
    }, 
    (err) => { // when rejected
        response.failure(res, next, {
                    message: 'ID does not exist'
                }, 404, response.HTTP_STATUS_CODES.not_found);
    });

这是
异步/等待
和
承诺
之间的比较：

下面是一些使用承诺的好例子：

我认为你的
$push
还行，但你已经说过了

这段代码在没有承诺的情况下运行

我希望这会有帮助，祝你好运：）
我试着清理我的代码

以下是controller.js：

/** Push usersession message  */
module.exports.pushsession =
    async(req, res, next) => {
        try {
            //jwt.validateToken(req);
            var en = "en";
            var dateEn = moment().locale(en);

            format = "MM/DD/YYYY h:mm:ss A"; //h:mm:ss.SSS if you want miliseconds

            var datetime_now = dateEn.format(format);

            console.log(datetime_now);

            var request = {

                    message_body: {
                        message: req.body.message,
                        message_type: req.body.message_type,
                        timestamp: datetime_now
                    }
            };

            const model = usersessionDB(req.query['client']);
            const id = req.body.fb_id;
            const result = await usersessionDB.pushsession(model, id, request);
            if (result) {
                response.success(res, next, result, 200, response.HTTP_STATUS_CODES.ok);
            } else {
                response.failure(res, next, {
                    message: 'ID does not exist'
                }, 404, response.HTTP_STATUS_CODES.not_found);
            }
        } catch (err) {
            response.failure(res, next, err, 500, response.HTTP_STATUS_CODES.internal_server_error);
        }
    }

/** Push usersession message  */
module.exports.pushsession =
   async (req, res, next) => {
        try {
            //jwt.validateToken(req);
            var en = "en";
            var dateEn = moment().locale(en);

            format = "MM/DD/YYYY h:mm:ss A"; //h:mm:ss.SSS if you want miliseconds

            var datetime_now = dateEn.format(format);

            console.log(datetime_now);

            var data = { 

                    message: req.body.message, 
                    message_type: req.body.message_type,
                    timestamp: datetime_now

            };


            const model = usersessionDB(req.query['client']);
            const id = req.body.fb_id;
            console.log(id);
            const result = await usersessionDB.pushsession(model, id, data).then(
                (result) => { // when resolved
                    response.success(res, next, result, 200, response.HTTP_STATUS_CODES.ok);
                }, 
                (err) => { // when rejected
                    response.failure(res, next, {
                                message: 'ID does not exist'
                            }, 404, response.HTTP_STATUS_CODES.not_found);
                });
        } catch (err) {
            response.failure(res, next, err, 500, response.HTTP_STATUS_CODES.internal_server_error);
        }
    }

下面是db.js：

const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const ObjectId = mongoose.Types.ObjectId;

const usersessionSchema = new Schema({
  fb_id: String,
  fb_name: String,
  fb_profpic: String,
  message_body: [
    {
      message: String,
      message_type: String,
      timestamp: String
    }
  ],
  admin: Boolean,
  branch: String
});

const model = (prefix) => {
    prefix = prefix || '';
    console.log(prefix);
    if (prefix.length > 0) {
        return mongoose.model(prefix + "-usersessions", usersessionSchema);
    } else {
        return new Error('Undefined collection prefix!');
    }
}
/** Push message into message body*/
    module.exports.pushsession =
        async(model, id, data) => {
            return new Promise((resolve, reject) => {
                console.log(data);
                model.findOneAndUpdate({fb_id: id}, {$push: {data}},{safe: true})
                    .then(res => {
                        console.log(res);
                        /
                        resolve(res);
                    })
                    .catch(err => {
                        reject(err);
                        console.log(err);
                        throw err;
                    });
        });
    }

const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const ObjectId = mongoose.Types.ObjectId;

const usersessionSchema = new Schema({
  fb_id: String,
  fb_name: String,
  fb_profpic: String,
  message_body:[{
      message: String,
      message_type: String,
      timestamp: String
  }],
  admin: Boolean,
  branch: String
});
/** Push message into message body*/
module.exports.pushsession =
async(model, id, data) => {
    console.log(data);
    return new Promise((resolve, reject) => {
        model.findOneAndUpdate({fb_id: id}, { $push: { message_body: data }})
        .then(res => {
            console.log(res);
            resolve(res);
        })
        .catch(err => {
            reject(err);
            console.log(err);
            throw err;
        });
    });
}

出乎意料的是，在我尝试用$set替换$push之后，我又用$push替换了它，它成功了。
我不知道是否有差异，或者我遗漏了什么，请随意指出。
Taki！：D我已经尝试删除了wait和async，但仍然得到了相同的结果？可能是因为
中的
/
。然后
在
console.log（）和
resolve（）之间
，最好在
$push
（
消息体：…
）中精确指定要更新的密钥，而不是将其传递到对象中，并且在控制器中使用
的方法是正确的。然后（）
而不是我在回答中提到的
result=wait…
），但是因为你说代码在没有
承诺的情况下工作
我没有看其他部分，无论如何，我很高兴你能做到这一点：）（只需将问题标记为已回答，其中一个答案标记为已接受）