Node.js Async Module Require - node.js

Question

I have a question regarding an express based node.js application that is dependent on the first require(). This is my first node.js application. The first require() hits AWS ec2 parameter store to gather credentials for a database. I can not make a connection to the database until this require resolves in an asynchronous manner.
The best way I've found to do this is to export a callback and wrap the rest of the require() statements in the callback of the first require(). Is this a bad practice?
//app.js
var appConfig = require('./config/appconfig');
appConfig.fetchAppConfig(function(err, result) {
if(err) {
console.log(err);
console.error("Server failed to startup. Config parameters not available.");
}
else {
var express = require('express');
var path = require('path');
var cookieParser = require('cookie-parser');
...
app.use(bodyParser.json());
etc
...
//appConfig.js
module.exports = function fetchAppConfig(callback) {
getCredentials(function(err, result) {
if(err) {
console.log(err);
callback(err);
} else {
awsLogin.paramStoreService(result).then(
data => {
appConfig = decodeAppConfig(data.Parameter.Value);
callback(null, appConfig);
}
).catch(
error => {
console.error(error);
callback(err);
}
)
}
})
}
Am I missing a more simple option?
Would I be better served to have this logic to pull the configuration somewhere in the deployment code?

Answer 1

I would define a couple of functions, one to request the credentials and another to connect to the database once the credentials are retrieved. You could use the async module's series function that will easily allow you to control the flow of your application.
From the documentation:
Run the functions in the tasks collection in series, each one running
once the previous function has completed. If any functions in the
series pass an error to its callback, no more functions are run, and
callback is immediately called with the value of the error. Otherwise,
callback receives an array of results when tasks have completed.
Here's an example:
var async = require('async');
function getCredentials(callback) {
callback(null, {
user: 'hello',
pass: 'world',
});
};
function connectToDatabase(callback, creds) {
console.log('Connecting to database => ' + JSON.stringify(creds));
callback(null, 'Done');
};
async.series([
getCredentials,
connectToDatabase,
],
function(err, results) {
console.error(err);
console.log(results);
});

Answer 2

Until node supports top-level awaits, below is the solution I'm using for this exact use-case.
// index.js
(async () => {
await require('./config').initialize();
require('./app');
})();
// config.js
const _ = require('lodash');
const secretKeys = ['secret1', 'secret2'];
const parameterHierarchyPrefix = `/${process.env.NODE_ENV}/app/`;
const getParamNameWithoutHierarchy = name => _.replace(name, new RegExp(`${parameterHierarchyPrefix}(.*)`), '$1');
const config = {};
config.initialize = async (callback = () => {}) => {
try {
// initialize aws sdk and ssm
const AWS = require('aws-sdk');
AWS.config.update({
region: 'us-west-2',
accessKeyId: S3_ACCESS_KEY,
secretAccessKey: S3_SECRET,
});
const ssm = new AWS.SSM();
// map secret keys to lowercase
const secretNames = _.map(secretKeys, key => `${parameterHierarchyPrefix}key`);
// this api only allows fetching 10 params per call
const secretFetchBatches = _.chunk(secretNames, 10);
// fetch secrets from aws parameter store
let secrets = {};
for (let i = 0; i < _.size(secretFetchBatches); i += 1) {
const parameters = await ssm.getParameters({
Names: secretFetchBatches[i],
WithDecryption: true,
}).promise();
secrets = {
...secrets,
..._.zipObject(_.map(parameters.Parameters, ({ Name }) => ([getParamNameWithoutHierarchy(Name)])), _.map(parameters.Parameters, 'Value')),
};
}
// write the secrets into the config object
_.each(secrets, (v, k) => constants[k] = v);
// invoke the callback
callback();
} catch (e) {
throw e
}
};
module.exports = config;