feat: Adds support for properly handling block_suggestion events

Create a block_suggestion handling workflow that mimics the current InteractionHandler
workflows. Add suggestionHandlers slice to slaccker struct. Adds SuggestionHandler and
SuggetionHandlerMiddleware functions. Adds logic in the main slacker.Listen func to
switch between generic Interactions and block_suggestion interaction types

executors.go

@@ -1,5 +1,7 @@
 package slacker
 
+import "github.com/slack-go/slack"
+
 func executeCommand(ctx *CommandContext, handler CommandHandler, middlewares ...CommandMiddlewareHandler) {
 	if handler == nil {
 		return
@@ -24,6 +26,18 @@ func executeInteraction(ctx *InteractionContext, handler InteractionHandler, mid
 	handler(ctx)
 }
 
+func executeSuggestion(ctx *InteractionContext, handler SuggestionHandler, middlewares ...SuggestionMiddlewareHandler) slack.OptionsResponse {
+	if handler == nil {
+		return slack.OptionsResponse{}
+	}
+
+	for i := len(middlewares) - 1; i >= 0; i-- {
+		handler = middlewares[i](handler)
+	}
+
+	return handler(ctx)
+}
+
 func executeJob(ctx *JobContext, handler JobHandler, middlewares ...JobMiddlewareHandler) func() {
 	if handler == nil {
 		return func() {}

handler.go

@@ -1,5 +1,9 @@
 package slacker
 
+import (
+	"github.com/slack-go/slack"
+)
+
 // CommandMiddlewareHandler represents the command middleware handler function
 type CommandMiddlewareHandler func(CommandHandler) CommandHandler
 
@@ -12,6 +16,12 @@ type InteractionMiddlewareHandler func(InteractionHandler) InteractionHandler
 // InteractionHandler represents the interaction handler function
 type InteractionHandler func(*InteractionContext)
 
+// SuggestionMiddlewareHandler represents the suggestion middleware handler function
+type SuggestionMiddlewareHandler func(SuggestionHandler) SuggestionHandler
+
+// SuggestionHandler represents the interaction handler function for block_suggestion
+type SuggestionHandler func(*InteractionContext) slack.OptionsResponse
+
 // JobMiddlewareHandler represents the job middleware handler function
 type JobMiddlewareHandler func(JobHandler) JobHandler
 

slacker.go

@@ -54,6 +54,7 @@ type Slacker struct {
 	commandMiddlewares            []CommandMiddlewareHandler
 	commandGroups                 []*CommandGroup
 	interactionMiddlewares        []InteractionMiddlewareHandler
+	suggestionMiddlewares         []SuggestionMiddlewareHandler
 	interactions                  []*Interaction
 	jobMiddlewares                []JobMiddlewareHandler
 	jobs                          []*Job
@@ -63,6 +64,7 @@ type Slacker struct {
 	onConnectionError             func(socketmode.Event)
 	onDisconnected                func(socketmode.Event)
 	unsupportedInteractionHandler InteractionHandler
+	suggestionHandler             SuggestionHandler
 	helpDefinition                *CommandDefinition
 	unsupportedCommandHandler     CommandHandler
 	unsupportedEventHandler       func(socketmode.Event)
@@ -306,10 +308,17 @@ func (s *Slacker) Listen(ctx context.Context) error {
 						continue
 					}
 
-					// Acknowledge receiving the request
-					s.socketModeClient.Ack(*socketEvent.Request)
+					switch callback.Type {
+					case slack.InteractionTypeBlockSuggestion:
+						// pass the socketEvent Request so that it can be Ack'd after the OptionsResponse is created
+						go s.handleInteractionSuggestion(ctx, *socketEvent.Request, &callback)
+						continue
+					default:
+						// Acknowledge receiving the request
+						s.socketModeClient.Ack(*socketEvent.Request)
 
-					go s.handleInteractionEvent(ctx, &callback)
+						go s.handleInteractionEvent(ctx, &callback)
+					}
 
 				default:
 					if s.unsupportedEventHandler != nil {
@@ -458,6 +467,18 @@ func (s *Slacker) handleInteractionEvent(ctx context.Context, callback *slack.In
 	}
 }
 
+func (s *Slacker) handleInteractionSuggestion(ctx context.Context, req socketmode.Request, callback *slack.InteractionCallback) {
+	blockResponse := slack.OptionsResponse{}
+	middlewares := make([]SuggestionMiddlewareHandler, 0)
+	middlewares = append(middlewares, s.suggestionMiddlewares...)
+
+	if s.suggestionHandler != nil {
+		interactionCtx := newInteractionContext(ctx, s.logger, s.slackClient, callback, nil)
+		blockResponse = executeSuggestion(interactionCtx, s.suggestionHandler, middlewares...)
+	}
+	s.socketModeClient.Ack(req, blockResponse)
+}
+
 func (s *Slacker) handleMessageEvent(ctx context.Context, event any) {
 	messageEvent := newMessageEvent(s.logger, s.slackClient, event)
 	if messageEvent == nil {