What kind of "non-Error instance" do you mean? I want to know your use case.

I ran into this with a library that throws Error-like objects that have the same shape but don't use the Error constructor. Testing this middleware right now, and it seems to fix the problem in my case:

// Handle Error-like exceptions and other non-Error Promise rejections so they're
// handled by `app.onError`, which is only triggered for instances of Error.
app.use(async (ctx, next) => {
    try {
        await next();
    } catch (err) {
        // If it's already an Error, rethrow it
        if (err instanceof Error) {
            throw err;
        }

        // Turn Error-like objects into Errors
        if (typeof err === 'object' && err !== null) {
            const e = new Error();
            if ('name' in err && typeof err.name === 'string') {
                e.name = err.name;
            }
            if ('message' in err && typeof err.message === 'string') {
                e.message = err.message;
            }
            if ('stack' in err && typeof err.stack === 'string') {
                e.stack = err.stack;
            }
            if ('cause' in err) {
                e.cause = err.cause;
            }
            throw e;
        }

        // Use strings as the error message
        if (typeof err === 'string') {
            throw new Error(err);
        }

        // Wrap other things in an Error
        throw new Error('Unknown error', { cause: err });
    }
});

However, it needs to be registered after other middlewares (like logger) that have logic after await next(), otherwise their functionality will break in the non-Error case.

Uh oh!

Let app.onError handle non-Error instance #667

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions