Async / await seems not to be functioning as expected.

I haven't dug deep enough into the code to fully know what's going on, but I have a few observations:

• Try and write your functions as pure functions. This is a function that does not cause side effects. It takes in input and returns output, and doesn't affect any variables outside of its scope. It's much easier to test, debug, and reason about your code this way. Right now it looks like you have functions that have side effects of changing global variables, but don't return anything. Returning values is also where a lot of the magic of promises comes in. If you define a function as being an async function, whatever you return from it will be a promise, whether you explicitly return a promise, or you return a simple value, it will wrap that value in a promise. This allows you to compose asynchronous functions together in a way that you make sure everything happens in the order you want it to.
• It also looks like you're assigning a value to a variable at the same time as passing it in as an argument. This is nonstandard and makes it hard to understand and debug. For example: return Promise.resolve(jsonKeysList = res.keys); This is assigning a new value to the global variable jsonKeysList, and also passing that value into Promise.resolve. (But since you don't return this promise, nothing is listening for the promise to be resolved, the only change is the global variable being changed).
• If you're going to use the async/await strategy (which I recommend) the way to catch errors is by wrapping code with try/catch blocks just like you can with synchronous code. You're mixing and matching traditional promises and async/await right now a bit, probably better to pick one style and stick with it.

So what I'm suggesting is something like this:

const getJsonKeys = (keysId) => {

    const options = {
        method: 'GET',
        uri: baseURL + keysID,
        headers: { 'User-Agent': 'Request-Promise' },
        json: true // Automatically parses the JSON string in the response
    };
    return rpn(options);
}

Then later on something can wait for the value that's returned from getJsonKeys, which will be a promise:

const doAnotherOperation = async () => {
    const keys = await getJsonKeys();
  // do something with the keys
}

Since I unwrapped the promise with await, it will be the json object, not a promise.

Thanks: That was really dumb. I know the difference between defining a function and calling a function but I still get caught by it.

Brendan:

I adapted your answer after spending the day doing extensive reading on promises (my head is awhirl but I think I'm getting closer). It isn't so much that I don't "get" promises (although that is part of it). I always get stuck with the resolution of the promise, in other words -- exposing the data. Here is how I solved it, and it works for now (though I may have trouble downstream).

//  GET the list of keys to JSON data files (returns a promise)
const getJsonKeys = async (req, res, next) => {

    const options = {
        method: 'GET',
        uri: baseURL + keysID,
        headers: { 'User-Agent': 'Request-Promise' },
        json: true // Automatically parses the JSON string in the response
    };
    const keyList = await rpn(options)
        .then(function (res) {
            return res.keys
        })
        .catch(function(err){
            console.log(err);
        });
    res = keyList
    return res;
};
//
// lots of intervening code
//
module.exports = (rtProcess) => {
    rtProcess.get('/process', function (req, res, next) {
        res.render('process');

        const resolveKeys = Promise.resolve(getJsonKeys());
        resolveKeys.then((jsonKeysList) => {
            console.log('Retrieve Keys');
            const writeEmptyKey = Promise.resolve(postEmptyJsonKeys()); //  reset the file keys List for next run
            writeEmptyKey.then((emptyKeysList) => {
                console.log('Wrote', emptyKeysList);
            });

            //  loop on the keys -- get and parse JSON, then write SQL
            for ( let i =0; i < jsonKeysList.length; i++ ) {
                courseID = jsonKeysList[i];
                console.log(courseID);
                //
                //   downstream code
                //
            }
            //
            //  more downstream code
            //  
        }); //  end of resolveKeys
    }); // end of process route
};  //  end of module exports

The thing I don't like about this solution is I can't figure out to raise the scope of jsonKeysList. I would rather close the resolve block right after the console.log('Retrieve Keys') and have jsonKeysList available for downstream processing, outside the block. But, since I could not get that to work, I punted and enclosed the downstream code inside the block for the sake of scope. I am hoping it doesn't rise up and bite me downstream.

The Good News is, I did isolate jsonKeysList as a standalone array. I can loop on it for the json data I need.

As you can see, I am still a rookie.