I'm trying to use the code from this answer to extend one OSS application.

However app.js is sync and no matter what I do, I cant force it to wait for the promise to resolve.

app.js

var cosmos = require('./cosmos.js');
const key = cosmos.key(var1, var2, var3);
console.log(key); // << shows Promise { <pending> }

mongoose.connect(`redacted`, {
  auth: {
    username: config.database.name,
    password: key
  }
});

cosmos.js

async function retriveKey(subId, resGrp, server) {
    const { EnvironmentCredential } = require("@azure/identity");
    const { CosmosDBManagementClient } = require("@azure/arm-cosmosdb");
    const armClient = new CosmosDBManagementClient(
        new EnvironmentCredential(), subId
    );

    const { primaryMasterKey } = await armClient.databaseAccounts.listKeys(
        resGrp, server
    );
    return new Promise(resolve => {
        setTimeout(() => resolve(primaryMasterKey), 1000);
    });
}

exports.key = retriveKey

If i console.log() inside the async function it actually shows the key, however mongoose db connection doesn't wait for the promise to get resolved, it starts connecting straight away and fails with something like: password must be a string.

If i hardcode actual key instead of this promise - everything works fine.

EDIT:

halfway there:

// pull cosmos keys
async function retriveKey(subId, resGrp, server) {
    const { EnvironmentCredential } = require("@azure/identity");
    const { CosmosDBManagementClient } = require("@azure/arm-cosmosdb");
    const armClient = new CosmosDBManagementClient(
        new EnvironmentCredential(), subId
    );
    const { primaryMasterKey } = await armClient.databaseAccounts.listKeys(
        resGrp, server
    );
    return primaryMasterKey // don't even need a promise here
}

exports.key = retriveKey

var mongooseConnected; // global variable
app.use(function (req, res, next) {
  if (!moongooseConnected) {
    moongooseConnected = cosmos.key(var1, var2, var3).then(function (key) {
      mongoose.connect(`xxx`,
        {
          auth: {
            username: config.database.name,
            password: key
          }
        }
      );
      console.log(key); // works as expected

      require('./models/user');
      require('./models/audit');

      require('./routes/user')(app);
      require('./routes/audit')(app, io);
    });
  }
  moongooseConnected.then(function () {
    next();
  });
});

the database connection gets established, console.log(key) shows proper key in the log, however no routes are present in the app.

if i move routes or models outside of this app.use(xyz) - i'm starting to see failures due to:

Connection 0 was disconnected when calling createCollection

or

MongooseError [MissingSchemaError]: Schema hasn't been registered for model "User".

which (i assume) means they require mongoose to be instantiated, but they are not waiting.

CodePudding user response：

If you switch from CommonJS modules to ES modules, you can use await to wait for a promise to resolve:

import cosmos from './cosmos.js';
const key = await cosmos.key(var1, var2, var3);
console.log(key);
await mongoose.connect(`redacted`, {
  auth: {
    username: config.database.name,
    password: key
  }
});

Alternatively, you can wait with the initialization of mongoose until the first request comes in, because express middleware is asynchronous:

var mongooseConnected; // global variable
function connectMongoose() {
  if (!mongooseConnected)
    mongooseConnected = cosmos.key(var1, var2, var3)
    .then(key => mongoose.connect(`redacted`, {
      auth: {
        username: config.database.name,
        password: key
      }
    }));
  return mongooseConnected;
}
module.exports = connectMongoose;

If the code above is needed elsewhere, it can be put in a separate module and imported wherever needed:

const connectMongoose = require("./connectMongoose");
app.use(function(req, res, next) {
  connectMongoose().then(function() {
    next();
  });
});
require('./routes/user')(app);
require('./routes/audit')(app, io);

Note that if several parallel requests come in, only the first of these will let the global variable mongooseConnected equal a promise, and all these requests will wait for it to resolve before calling next().

Also note that additional routes of app must be registered after this app.use command, not inside it.

CodePudding user response：

unless somebody comes up with a way to do this with less changes to the original code base, this is what I'm using:

cosmos.js

// pull cosmos keys
async function retriveKey(subId, resGrp, server) {
    const { DefaultAzureCredential } = require("@azure/identity");
    const { CosmosDBManagementClient } = require("@azure/arm-cosmosdb");
    const armClient = new CosmosDBManagementClient(
        new DefaultAzureCredential(), subId
    );
    const { primaryMasterKey } = await armClient.databaseAccounts.listKeys(
        resGrp, server
    );
    return primaryMasterKey
}

exports.key = retriveKey

app.js

// pull cosmos keys
var cosmos = require('./cosmos');
let key = cosmos.key(var1, var2, var3)
mongoose.connect(
  `xxx`,
  {
    auth: {
      username: config.database.name,
      password: key
    }
  }
).catch(
  err => {
    console.log("dOrty h4ck");
    key.then(k => mongoose.connect(
      `xxx`,
      {
        auth: {
          username: config.database.name,
          password: k
        }
      }
    )
    );
  }
)

basically, like Heiko mentioned, mongoose.connect() is actually async, but somehow blocking (??). so while first mongoose.connect() always fails - it gives enough time for the code to retrieve the key, then I catch the error and connect again. no other changes to the original code base are needed.