# InteractionMiddleware

`class` in `http` · v0.8.0

<https://docs.seedcord.org/packages/http/0.8.0/classes/interaction-middleware>

Base class for interaction middleware on the HTTP transport.

Middleware runs after the dispatcher builds the handler and before the gates, over the handler's own reply surface. Name the kinds in the generic and list the same ones in `{ kinds }`. Several kinds give `this.event` a union. Narrow it on `type` and `data.component_type`. A catchall reads every repliable kind.

```ts
abstract class InteractionMiddleware<
    Kind extends MiddlewareKind = MiddlewareKind
> extends RepliableHandler<InteractionOf<Kind>>
```

## Examples

```ts
\@RegisterInteractionMiddleware({ kinds: [InteractionKind.Button] })
class Audit extends InteractionMiddleware<InteractionKind.Button> {
    async execute() {
        this.logger.info(this.event.data.custom_id);
    }
}
```

## Constructors

### constructor

```ts
InteractionMiddleware(
    event: InteractionOf<Kind>,
    core: Core,
    dispatch: DispatchContext,
    sender: ReplySender
)
```

Constructs a new instance of the `InteractionMiddleware` class

## Properties

### api

```ts
protected api: API
```

Typed Discord REST API (`@discordjs/core/http-only`) over `core.rest`, one instance per core. The interaction callbacks on `api.interactions` bypass the reply surface. The `no-raw-interaction-acks` rule flags them in handler classes.

### core

```ts
readonly core: TCore
```

### dispatch

```ts
protected readonly dispatch: DispatchContext
```

The bag for this dispatch. Each interaction gets its own. Every handler for one event shares a single bag.

### event

```ts
protected readonly event: Event
```

### logger

```ts
protected readonly logger: Logger
```

### routeId

```ts
protected readonly routeId: string
```

### sender

```ts
readonly sender: TSender
```

The reply surface for this interaction. Pass the handler to reply from outside its class.

## Methods

### after

```ts
public async after(result: DispatchResult): Promise<void>
```

Runs once the handler settles, newest middleware first. A refusal or a throw still reaches it, since seedcord calls it on every middleware whose `execute()` started. Implement it to release something this middleware took in `execute()`, such as a lock or an open span. A throw in here is logged and goes no further.

### buildSender

```ts
protected buildSender(
    event: Event,
    core: Core,
    dispatch: DispatchContext
): ReplySender
```

### defer

```ts
protected async defer(opts?: DeferOpts): Promise<void>
```

Show a "thinking" placeholder, then fill it later with [`edit`](/packages/http/0.8.0/classes/user-menu-handler#edit).

### delete

```ts
protected async delete(target?: TMessage): Promise<void>
```

Delete the initial reply or deferred placeholder. Pass a target to delete a message a prior send returned.

### edit

```ts
protected async edit(
    response: ReplyResponse<TNative> | string
): Promise<TMessage>
```

```ts
protected async edit(
    target: TMessage,
    response: ReplyResponse<TNative> | string
): Promise<TMessage>
```

Rewrite the initial reply or deferred placeholder. The targeted form rewrites a message a prior send returned.

### execute

```ts
abstract async execute(): Promise<void>
```

Holds the main logic of your handler. The dispatcher calls it after the handler's gates pass, so a gate that refuses stops `execute()` from running.

### followUp

```ts
protected async followUp(
    response: ReplyResponse<TNative> | string,
    opts?: SendOpts
): Promise<TMessage>
```

Send a new message once the interaction is acknowledged.

### reply

```ts
protected async reply(
    response: ReplyResponse<TNative> | string,
    opts?: SendOpts
): Promise<TMessage>
```

Send the initial response, exactly once.

### send

```ts
protected async send(
    response: ReplyResponse<TNative> | string,
    opts?: SendOpts
): Promise<TMessage>
```

Routes to reply, followUp, or edit based on the current ack state.