accessing value of variable outside of async/await iife

Question

I have the code below. I need to use the value of con in other functions but I have no possible solution for this. I tried using .thens and awaits like other stack articles but i kept getting the error that con is not valid.

I am truly stuck and unsure how to handle this.

service.js

async function connectToDatabase(secret) {
  
  try {
      const secretValue = await getSecretPromise(secret)

      const { host, port, username, password, dbname } = JSON.parse(secretValue);

      let con = mysql.createConnection({
          host: host,
          port: port,
          user: username,
          password: password,
          database: dbname
      });
      con.connect(function(err) {
        if (err) throw err;
        console.log("Connected to database!");
      });
      return con;
  } catch (error) {
      console.error(error)
  }
}

// Start an IIFE to use `await` at the top level
(async function(){
  let con = await connectToDatabase(secretName);
})();

function createUser({ data }) {
  return new Promise((resolve, reject) => {
    var sql = `query`;
    con.query(sql, function (err, result) {
      //does not work currently because ReferenceError: con is not defined
    });
  });
}

controller.js

async function getUsers(req, res, next) {

    service.getUsers().then(function(val) {
        res.json(val)
    });
}

getsecretpromise

function getSecretPromise(secretName) {
  return new Promise((resolve, reject) => {
    client.getSecretValue({SecretId: secretName}, function(err, data) 

    {
      //do stuff
    }
    }

service.getUsers

//this is in service.js
module.exports = {
  createUser,
  getUsers,
  patchUser,
  loginUser,
  updateCallForward,
  getEmail,
  getCallForwardingNumber,
  getDB
};

function getUsers() {
  return new Promise((resolve, reject) => {

    var sql = `sql`;

    getDB().then(con => {
      con.query(sql, function (err, result) {
        if (err) throw err;
        resolve(result);
      });
    });

  });
}

`const secretValue = await getSecretPromise(secret)` why is this a Promise? Seems like that's the only reason you have to use promises here — Luca Kiebel, Jan 09 '22 at 17:30
because I am getting a value from an API so I need that @LucaKiebel — Juliette, Jan 09 '22 at 17:31
You can ignore the first part of T.J.'s answer, the rest hopefully helps — Luca Kiebel, Jan 09 '22 at 17:34
@LucaKiebel not sure how that exactly helps do you mind elaborating — Juliette, Jan 09 '22 at 17:35
You can wrap it in a static class. Simply add static private db and a public getter to return the instance. If it is null you can call connect on first get. — Berkays, Jan 09 '22 at 17:37
Why not just declare con in the global scope of the service module? — entitycs, Jan 09 '22 at 17:40
The code will remain in a tangle as long as promise-style and callback-style calls are intermixed. I think the way forward is to either switch to a promise-ified version of the sql package, or roll your own by making a promise-returning version of each mysql entry point that you use. — danh, Jan 09 '22 at 18:37
@Juliette const con = (async function (){ return await connectToDatabase(secretName) })(); — entitycs, Jan 09 '22 at 18:57
Yes, then assuming you are inside of non-async code (ie. at the top level), you can use the Promise.then() function to continue. Example: https://jsfiddle.net/gLpuvqjn/ — entitycs, Jan 09 '22 at 19:11

SoloOrchid · Answer 1 · 2022-01-09T17:51:56.383

You are defining the con variable after it's being returned, your IIFE starts working once it is read. What I am trying to say is you need to move that function up and if thats not an option then you need to define con before returning it. If you alredy defined it before this function then I dont know.

async function connectToDatabase(secret) {
  
    // Start an IIFE to use `await` at the top level
    (async function(){
      let con = await connectToDatabase(secretName);
    })();

    try {
        const secretValue = await getSecretPromise(secret)

        const { host, port, username, password, dbname } = JSON.parse(secretValue);

        let con = mysql.createConnection({
            host: host,
            port: port,
            user: username,
            password: password,
            database: dbname
         });
         con.connect(function(err) {
             if (err) throw err;
             console.log("Connected to database!");
         });
         return con;
    } catch (error) {
          console.error(error)
    }
}

function createUser({ data }) {
    return new Promise((resolve, reject) => {
        var sql = `query`;
        con.query(sql, function (err, result) {
        //does not work currently because ReferenceError: con is not defined
    });
  });
}

Did you try putting the con function beofre your connectToDatabase function too? — SoloOrchid, Jan 11 '22 at 08:16

Berkays · Answer 2 · 2022-01-09T18:25:13.397

0

You would ideally do something like this. This would hide your instance(not really for this case) from rest of the code as you will access it through a getter function. Of course you need to import your secret as a constant. It doesn't make sense to pass it as a parameter unless you have multiple dbs

let con = null;

async function connectToDatabase(secret) {

    try {
        const secretValue = await getSecretPromise(secret)

        const { host, port, username, password, dbname } = JSON.parse(secretValue);

        con = mysql.createConnection({
            host: host,
            port: port,
            user: username,
            password: password,
            database: dbname
        });
        con.connect(function (err) {
            if (err) throw err;
            console.log("Connected to database!");
        });
        return con;
    } catch (error) {
        console.error(error)
        con = null;
    }
}

export async function getDB() {
    if (con == null) {
        let secretObj = {};
        return await connectToDatabase(secretObj);
    }
    else {
        return Promise.resolve(con);
    }
}

export function createUser({ data }) {
    return new Promise((resolve, reject) => {
        var sql = `query`;
        getDB().then(con => {
            con.query(sql, function (err, result) {
                //does not work currently because ReferenceError: con is not defined
            });
        });
    });
}

edited Jan 09 '22 at 18:25

answered Jan 09 '22 at 18:13

Berkays

364
3
10

this gives me an error. export async function getDB() { ^^^^^^ SyntaxError: Unexpected token 'export' – Juliette Jan 09 '22 at 18:21
you are probably using an old version of js. Replace all `export` with `module.exports =` – Berkays Jan 09 '22 at 18:24
no error is thrown but i get a pending request – Juliette Jan 09 '22 at 18:28
look at new image above – Juliette Jan 09 '22 at 18:28
where is the code for `service.getUsers()`? – Berkays Jan 09 '22 at 18:37
check update to my post – Juliette Jan 09 '22 at 18:40
Might be a binding issue. Try `val => res.json(val)` instead of `function(val) { res.json(val) });` – Berkays Jan 09 '22 at 18:46
are you referring to this post? – Juliette Jan 09 '22 at 18:53
This does not do what you expect. If you call `getDB()` twice, it sometimes does create two connections to the database. – Bergi Jan 09 '22 at 19:14

score 0 · Answer 3 · answered Jan 09 '22 at 18:44

The code can be simplified (and repaired) by making promise-returning versions of the mysql callback style functions...

async function connect(connection) {
   return new Promise((resolve, reject) => {
     connection.connect(function (err) {
       err ? reject(err) : resolve(connection)
     });
   })
}

async function query(connection, query) {
  return new Promise((resolve, reject) => {
   connection.query(query, function (err, results, fields) {
     err ? reject(err) : resolve({results, fields});
   });
 });
}

Only these functions should create new promises explicitly. This cleans up the connectToDatabase function...

async function connectToDatabase(secret) {
  try {
      const secretValue = await getSecretPromise(secret)
      const { host, port, username, password, dbname } = JSON.parse(secretValue);

      let con = mysql.createConnection({
          host: host,
          port: port,
          user: username,
          password: password,
          database: dbname
      });
      return await connect(con);
  } catch (error) {
      console.error(error)
  }
}

And it cleans up createUser substantially...

async function createUser({ data }) {
  try {
    const connection = await connectToDatabase(secretName);
    let {results, fields} = query(connection, 'query');
    // and so on
   
  } catch(error) {
    console.log(error);
  }
}

Not that getSecretPromise() might require the same treatment, but is not completely specified in the OP.

Other caveats: not tested (or even compiled). Relies on values in scope whose definitions are not shown in the OP (e.g. secretName).

accessing value of variable outside of async/await iife

3 Answers3