I am not really sure I understand your question. For the most part, when using async/await, you can think of...and therefor write...asynchronous code like you write synchronous code. You don't have to do anything different, and if you have good error handling skills with synchronous code, then the same skills should apply with async/await code.

Consider:

async doSomeAsyncWork() {
   try {
       const requiredResult1 = await someAsyncServiceCall(...);
       let transform = someSyncUtilityCall(requiredResult1);
       const optionalResult2 = await someOtherAsyncServiceCall(...);
       transform = {
           ...transform,
           ...optionalResult2
       };
       return transform;
   } catch (err) {
       throw new Error(...);
   }
}

The catch will handle errors from all three calls...synchronous or asynchronous. If you need to handle one particular call in a unique way:

async doSomeAsyncWork() {
   try {
       const requiredResult1 = await someAsyncServiceCall(...);
       let transform = someSyncUtilityCall(requiredResult1);
       try {
           const optionalResult2 = await someOtherAsyncServiceCall(...);
           transform = {
               ...transform,
               ...optionalResult2
           };
       } catch {
           transform.noOptionalResult = true;
       }
       return transform;
   } catch (err) {
       throw new Error(...);
   }
}

It is just "normal" try/catch error handling. Nothing particularly special here. You could, of course, refactor the second example above to be simpler and easier to read and maintain:

async doSomeAsyncWork() {
   try {
       const requiredResult1 = await someAsyncServiceCall(...);
       let transform = someSyncUtilityCall(requiredResult1);
       return doSomeMoreAsyncWork(transform);
   } catch (err) {
       throw new Error(...);
   }
}

async doSomeMoreAsyncWork(transform) {
    try {
       const optionalResult2 = await someOtherAsyncServiceCall(...);
       transform = {
           ...transform,
           ...optionalResult2
       };
    } catch {
        transform.noOptionalResult = true;
    }

    return transform;
}

I presume you're asking about something like Express middleware:

Middleware is not the appropriate place to deal with this type of error handling because middleware chains function calls rather than wraps them.

Instead one approach to use is to create a function named something like asAsync() and wrap the route handler with that. Example:

function asAsync(handler) {
    return async (req, res, next) => {
        try {
            await handler(req, res, next);
            next();
        } catch (err) {
            next(err); 
        }
    }
}

app.get('/names', asAsync(async (req, res) => { 
    const names = await db.names.findAll();
});

An even nicer way, if you're using TypeScript, is to use decorators, exemplified by libraries like inversify-express-utils or NestJS. These frameworks use decorators to abstract away the repetitive code. A route handler in NestJS simply looks like this:

@Get('/names')
async get(req, res) {
    return await db.names.findAll();
}