Async/Await with Lambda and Database Calls

Question

After going through async/await docs I am still not able to figure out the error in my code. I am trying to do the following when the lambda is invoked.

Log the request object
Do Database Operation
Log the response Object

All of these need to be done in sync.

The below is the code snipped of my logic

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

All the combinations of async/await that I try just don't seem to be working. Can someone please guide?

Update II:

With the below code i do manage to get them execute in sequence however i am not able to get the value from the second lambda function

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

My Common-Logger Lambda Function

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

Find the AWS Logs attached

Don't pass callbacks to asynchronous function when you want to use promises (with async/await). — Bergi
– Bergi, Commented Nov 21, 2020 at 17:55
con.query(userValidationSQL, [email, password], async(userValidationError, userValidationResponse) => { … }) is passing a callback. Promisify that method so that you can properly await it. — Bergi
– Bergi, Commented Nov 21, 2020 at 18:11
Mixing callbacks with async/await reduces readability. Even if you'd have to manually promisify the function, do it. — Wiktor Zychla
– Wiktor Zychla, Commented Nov 21, 2020 at 20:38

Hossam ELMansy · Accepted Answer · 2020-11-21 20:32:45Z

I refactored it for you, you can try it:

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

now i dont see the logger getting invoked nor does my db call gets fired.

Collectives™ on Stack Overflow

Async/Await with Lambda and Database Calls

1 Answer 1

2 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related