reusable handlers

Reusable Handlers

You can easily define reusable handlers by implementing a factory function:

function MyHandler(): MethodDecorator {
    return HandleError(
        // ...
    )
}

class Foo {
    @MyHandler()
    public async bam(): Promise<void> {
        // ...
    }

    @MyHandler()
    public async baz(): Promise<void> {
        // ...
    }
}

For more advanced use cases you can of course also parameterize the factory function:

class ErrorWrapper extends Error {
    public readonly cause: Error

    public constructor(cause: Error) {
        super('An error occurred')

        this.cause = cause
    }
}

function CatchAll<T extends ErrorWrapper>(Clazz: Class<T>): MethodDecorator {
    return HandleError(
        {
            action: HandlerAction.MAP,
            callback: error => new Clazz(error)
        }
    )
}

class FooErrorWrapper extends ErrorWrapper {}
class BarErrorWrapper extends ErrorWrapper {}

class Foo {
    @CatchAll(FooErrorWrapper)
    public async foo(): Promise<void> {
        // ...
    }

}

class Bar {
    @CatchAll(BarErrorWrapper)
    public async foo(): Promise<void> {
        // ...
    }
}