v1.0.0-next adds a massive simplfiication and breaking change to interceptors:

1. We're removing NexusCommandInterceptor methods on the next possible version in favor Nexus.interceptors (e.g. Nexus.interceptors.middleware(name) { ev -> .. })
2. We're removing NexusCommandInterceptorRepository altogether on the next possible version, this is because we now have a better reflection engine that can handle more tasks and operations, allowing us to collect the fields and add them directly. See the NexusCommonInterceptors.

After some little work, I've noticed that afterwares behavior was reversed in a older commit where they no longer execute even if the command was stopped by a middleware. It's the correct behavior, but we need some way to at least identify when it fails, and that is the onFailedDispatch override function in NexusAfterware interface.

By overidding the onFailedDispatch, you can listen to when a command failed to dispatch, usually because a middleware stopped the command from dispatching. You can see an example on the new NexusLogAfterware.

A key benefit we can get from failedDispatch event is that we can log additional data from the middleware, if they used the event.store(...), for example, the common ratelimiter of Nexus supports this and is used in the new common log afterware to produce logs such as this:

You can now get the middleware that blocked the execution on your afterware by getting the value of Nexus[NexusAfterware.BLOCKING_MIDDLEWARE_KEY] which is only available in afterwares.

Nexus now natively supports user and message context menus. To get started, simply create a new class or object that inherits the NexusUserContextMenu or NexusMessageContextMenu abstract class and play with it like slash commands do:

object TestUserContextMenu: NexusUserContextMenu() {
    val name = "test"
    override fun onEvent(event: NexusContextMenuEvent<UserContextMenuCommandEvent, UserContextMenuInteraction>) {
        event.respondNowEphemerallyWith("Hello")
    }
}

object TestMessageContextMenu: NexusMessageContextMenu() {
    val name = "test"
    override fun onEvent(event: NexusContextMenuEvent<MessageContextMenuCommandEvent, MessageContextMenuInteraction>) {
        event.respondNowEphemerallyWith("Hello")
    }
}

To register them, simply use the Nexus.contextMenus method:

Nexus.contextMenus(TestUserContextMenu, TestMessageContextMenu)

We do not have support for afterwares and middlewares for context menus as we have no simpler middle between the two events. Additionally, to prevent something crazy, context menus are not included in the global.inheritance as it doesn't inherently support the same properties and functionalities as the slash commands.

It's almost time for Nexus 1.0, the following additional changes have been made:

1. Fixed NexusMiddlewareEvent.interaction resulting in a NoClassDefError (related: https://youtrack.jetbrains.com/issue/KT-12466)
2. Added support for inheritance with superclass fields.
3. Added additional utilities for NexusMessage (Kotlin-only).
4. Nexus will now use NexusConsoleLoggingAdapter by default whenever there is no SLF4J logger (to prevent important details from being hidden away).

And some more stability and maintainability changes. Note that this change will introduce quite a lot of breaking changes that will need a lot of work, but it is for the sake of keeping the API more consistent.

NexusConsoleLoggingAdapter now uses System.err (stderr) for error outputs, allowing for better logging with tools like Loki. Additionally, NexusConsoleLoggingAdapter can now handle throwing exceptions as long as there is no placeholders used (which in the modern Nexus, there shouldn't be any placeholders used now as we use Kotlin for this).