Javascript 使用Lamba和数据库调用进行异步/等待

经过异步/等待文档之后，我仍然无法找出代码中的错误。在调用lambda时，我尝试执行以下操作

记录请求对象

执行数据库操作

记录响应对象

所有这些都需要同步完成

下面是我的逻辑代码

    var AWS = require('aws-sdk');
    var lambda = new AWS.Lambda({ region: 'ap-south-1' });
    var mysql = require('/opt/node_modules/mysql');
    var config = require('/opt/config.json');
    var con = mysql.createConnection({
     host: config.dbhost,
     user: config.dbuser,
     password: config.dbpassword,
     database: config.dbname,
    });

exports.handler = async function(event, context, callback) {
    context.callbackWaitsForEmptyEventLoop = false;
    let response = null;
    let errors = [];
    try {
        let body = JSON.parse(event.body);
        const email = body.email;
        const password = body.password;

        let loggerObject = {
            email: email,
            feature: 'LOGIN',
            request: JSON.stringify(body)
        };
        let loggerResponseCallback = await logRequest(loggerObject);
        console.log(loggerResponseCallback);
        const userValidationSQL = `SELECT QUERY`;
        await con.query(userValidationSQL, [email, password], async(userValidationError, userValidationResponse) => {
            if (userValidationError) {
                throw userValidationError;
            }
            console.log(" User Validation Response", userValidationResponse);
            loggerObject = {
                email: email,
                feature: 'LOGIN',
                response: JSON.stringify(userValidationResponse)
            }
            loggerResponseCallback = await logRequest(loggerObject);
            console.log(loggerResponseCallback);
            callback(null, {
                statusCode: 200,
                headers: {
                    "Access-Control-Allow-Origin": "*"
                },
                body: JSON.stringify({ status: 'success', data: userValidationResponse }),
            }) //callback
        })
    }
    catch (error) {
        console.log(" catch========== ", error)
        callback(null, {
            statusCode: 400,
            headers: {
                "Access-Control-Allow-Origin": "*"
            },
            body: JSON.stringify({ status: 'error', message: 'Bad Request', error: errors }),
        })
    }
};



async function logRequest(loggerObject) {
    console.log("Invoking Logger Function");
    let params = {
        FunctionName: 'common-logger',
        InvocationType: 'RequestResponse',
        LogType: 'Tail',
        Payload: JSON.stringify(loggerObject)
    };

    await lambda.invoke(params, function(loggerError, loggerResponse) {
        if (loggerError) {
            console.log("Error in invoking Logger Function ", loggerError)
        }
        console.log('Logger Response:', loggerResponse);
        return loggerResponse;
    });
}

我尝试的所有async/await组合似乎都不起作用。有人能给我引路吗

更新二：

使用下面的代码，我确实设法让它们按顺序执行，但是我无法从第二个lambda函数中获得值

var AWS = require('aws-sdk');
var mysql = require('/opt/node_modules/mysql');
var con = mysql.createConnection({
    host: config.dbhost,
    user: config.dbuser,
    password: config.dbpassword,
    database: config.dbname,
});

exports.handler = function(event, context, callback) {
    context.callbackWaitsForEmptyEventLoop = false;
    let response = null;
    let errors = [];
    try {
        let body = JSON.parse(event.body);
        const email = body.email;
        const password = body.password;
        
        let loggerObject = {
            email: email,
            feature: 'LOGIN',
        };
        let loggerResponseCallback = logRequest(loggerObject);
        console.log('First loggerResponseCallback:', loggerResponseCallback);
        const userValidationSQL = `SELECT Query`;
        con.query(userValidationSQL, [email, password], (userValidationError, userValidationResponse) => {
            if (userValidationError) {
                throw userValidationError;
            }
            console.log(" User Validation Response", userValidationResponse);
            loggerObject = {
                email: email,
                feature: 'LOGIN',
                method: 'POST',
            };
            loggerResponseCallback = logRequest(loggerObject);
            console.log('Second loggerResponseCallback:', loggerResponseCallback);
            callback(null, {
                statusCode: 200,
                headers: {
                    "Access-Control-Allow-Origin": "*"
                },
                body: JSON.stringify({ status: 'success', data: userValidationResponse }),
            }) //callback
        })
    }
    catch (error) {
        console.log(" catch========== ", error)
        callback(null, {
            statusCode: 400,
            headers: {
                "Access-Control-Allow-Origin": "*"
            },
            body: JSON.stringify({ status: 'error', message: 'Bad Request', error: errors }),
        })
    }
};



async function logRequest(loggerObject) {
    var lambda = new AWS.Lambda({ region: 'ap-south-1' });
    console.log("Invoking Logger Function");
    let params = {
        FunctionName: 'common-logger',
        InvocationType: 'RequestResponse',
        LogType: 'Tail',
        Payload: JSON.stringify(loggerObject)
    };
    await lambda.invoke(params, function(loggerError, loggerResponse) {
        if (loggerError) {
            console.log("Error in invoking Logger Function ", loggerError)
        }
        console.log('Logger Response:', loggerResponse);
        return loggerResponse;
    });
}

我常用的Lambda函数

var mysql = require('/opt/node_modules/mysql');
var config = require('/opt/config.json');
var con = mysql.createConnection({
    host: config.dbhost,
    user: config.dbuser,
    password: config.dbpassword,
    database: config.dbname,
});

exports.handler = (event, context, callback) => {
    context.callbackWaitsForEmptyEventLoop = false;
    console.log('invoked logger');
    let loggerId = -1;
    try {
        let email = null,
        
        const sql = 'INSERT QUERY';
        con.query(sql, [ email], (err, res) => {
            if (err) {
                console.log(err)
                throw err;
            }
            loggerId = res.insertId
            console.log('Logger Response:', loggerId);
            if (!correlationID) {
                const sql = 'UPDATE LOGGER SET correlationId = ? WHERE ID = ?';
                con.query(sql, [loggerId, loggerId], (err, res) => {
                    if (err) {
                        console.log(err)
                        throw err;
                    }
                    console.log("Updated CorrelationId for Record:" + loggerId);
                }); //con.query
            }
            callback(null, {
                statusCode: 200,
                headers: {
                    "Access-Control-Allow-Origin": "*"
                },
                body: JSON.stringify({
                    status: 'success',
                    data: { "correlationId": loggerId }
                })
            })
        }); //con.query

    }
    catch (error) {
        console.log("catch", error);
    }
};

---

找到附加的AWS日志

我为您重构了它，您可以尝试：

var AWS = require("aws-sdk");
var lambda = new AWS.Lambda({ region: "ap-south-1" });
var mysql = require("/opt/node_modules/mysql");
var config = require("/opt/config.json");
var con = mysql.createConnection({
  host: config.dbhost,
  user: config.dbuser,
  password: config.dbpassword,
  database: config.dbname,
});

exports.handler = async function (event, context, callback) {
  context.callbackWaitsForEmptyEventLoop = false;
  let response = null;
  let errors = [];

  try {
    let body = JSON.parse(event.body);
    const email = body.email;
    const password = body.password;
    let loggerObject = {
      email: email,
      feature: "LOGIN",
      request: JSON.stringify(body),
    };

    let loggerResponseCallback = await logRequest(loggerObject);
    console.log(loggerResponseCallback);
    const userValidationSQL = `SELECT QUERY`;
    con.query(
      userValidationSQL,
      [email, password],
      async (userValidationError, userValidationResponse) => {
        if (userValidationError) {
          throw userValidationError;
        }
        console.log(" User Validation Response", userValidationResponse);
        loggerObject = {
          email: email,
          feature: "LOGIN",
          response: JSON.stringify(userValidationResponse),
        };
        loggerResponseCallback = await logRequest(loggerObject);
        console.log(loggerResponseCallback);
        callback(null, {
          statusCode: 200,
          headers: {
            "Access-Control-Allow-Origin": "*",
          },
          body: JSON.stringify({
            status: "success",
            data: userValidationResponse,
          }),
        }); //callback
      }
    );
  } catch (error) {
    console.log(" catch========== ", error);
    callback(null, {
      statusCode: 400,
      headers: {
        "Access-Control-Allow-Origin": "*",
      },
      body: JSON.stringify({
        status: "error",
        message: "Bad Request",
        error: errors,
      }),
    });
  }
};

async function logRequest(loggerObject) {
  console.log("Invoking Logger Function");
  let params = {
    FunctionName: "common-logger",
    InvocationType: "RequestResponse",
    LogType: "Tail",
    Payload: JSON.stringify(loggerObject),
  };
  try {
    const loggerResponse = await lambda.invoke(params).promise();
    console.log("Logger Response:", loggerResponse.Payload);
    return loggerResponse.Payload;
  } catch (loggerError) {
    console.log("Error in invoking Logger Function ", loggerError);
  }
}

---

当您想要使用承诺时（使用

async

/

wait

），不要将回调传递给异步函数。我认为我没有传递任何回调

con.query（userValidationSQL，[电子邮件，密码]，async（userValidationError，userValidationResponse）=>{…}

正在传递回调。将回调与async/await混合使用会降低可读性。即使您必须手动提示该函数，也要这样做。现在我看不到记录器被调用，我的db调用也不会被触发。好的，很抱歉我犯了一个错误，请现在尝试。