Yesterday, I spent a significant amount of time tracking down a bug in one of CSS MetadataWriter instances .

I set a debugger breakpoint in my editor at the point where I thought an error was being thrown, but I was able to "Next Step" past that code without entering the expected "catch" block. After stepping through the code for a while, I unexpectedly ended up in a higher-level catch block.

This was confusing—why wasn't the buggy part triggering the catch, and why did the catch only execute after processing code that appeared safe?

After several hours, I realized that all MetadataWriter instances are invoked in a ParallelHandler using Promise.all as shown:

 return Promise.all(this.handlers.map(async(handler): Promise<TOut> => handler.handle(input)));

If one of the handlers throws an error, the implementation executes all the handlers and waits for every promise to resolve before throwing the error. That’s why, in the debugger, I wasn’t redirected to a catch block immediately after the suspicious code (the debugger jumped to the next handler) and only reached the catch block after all promises resolved and the error was thrown by the last handler. This behavior now makes sense, although it was difficult to diagnose at first.

I’m concerned that if this happens again, I might forget the details—and other developers might face the same issue.

A solution that could have save me time is to wrap the Promise.all in a try-catch block:

     return Promise.all(
      this.handlers.map(
        async(handler): Promise<TOut> => {
          try {
            return await handler.handle(input)
          } catch(error) {
            this.logger.error(`${handler.constructor.name}: ${error}`)
            throw error
          }
        }));

With the above, the developer is cleary informed which handler caused the error. Which drastically help scoping the bug in contrast to an error from HandlerServerConfigurator.ts

@joachimvh, I understand if you dont want to add try-catch blocks everywhere as it might seem messy, but I believe this change could really help with debugging. Would you be open to a PR implementing this improvement?