example_test.go

package dispatcher_test

import (
	"context"
	"fmt"

	"github.com/struct0x/dispatcher"
)

func loggingMiddleware[T any]() dispatcher.Middleware[T] {
	return func(next dispatcher.HandlerFunc[T]) dispatcher.HandlerFunc[T] {
		return func(ctx context.Context, event T) error {
			fmt.Printf("Processing event: %T\n", event)
			err := next(ctx, event)
			if err != nil {
				fmt.Printf("Error processing event: %v\n", err)
				return err
			}
			fmt.Printf("Successfully processed event: %T\n", event)
			return nil
		}
	}
}

func Example() {
	reg := dispatcher.NewRegistry()

	// Define event types
	type UserCreated struct {
		ID   int
		Name string
	}

	type OrderPlaced struct {
		OrderID string
		Amount  float64
	}

	type Unknown struct {
		Foo string
	}

	// Create middleware using the helper function
	validationMiddleware := dispatcher.MiddlewareFunc(func(ctx context.Context, event UserCreated) (bool, error) {
		if event.ID <= 0 {
			return false, fmt.Errorf("invalid user ID: %d", event.ID)
		}
		if event.Name == "" {
			return false, fmt.Errorf("user name cannot be empty")
		}
		return true, nil // Continue processing
	})

	// Register handlers for different types
	dispatcher.Register(
		reg,
		func(ctx context.Context, event UserCreated) error {
			fmt.Printf("User created: %s (ID: %d)\n", event.Name, event.ID)
			return nil
		},
		validationMiddleware,
		loggingMiddleware[UserCreated](),
	)

	dispatcher.Register(
		reg,
		func(ctx context.Context, event OrderPlaced) error {
			fmt.Printf("Order placed: %s for $%.2f\n", event.OrderID, event.Amount)
			return nil
		},
		loggingMiddleware[OrderPlaced](),
	)

	// Dispatch events
	ctx := context.Background()

	_ = dispatcher.Dispatch(reg, ctx, UserCreated{ID: 1, Name: "Alice"})
	_ = dispatcher.Dispatch(reg, ctx, OrderPlaced{OrderID: "ORD-001", Amount: 99.99})

	sealedReg := reg.Seal()
	_ = dispatcher.Dispatch(sealedReg, ctx, UserCreated{ID: 2, Name: "Alice"})
	_ = dispatcher.Dispatch(sealedReg, ctx, OrderPlaced{OrderID: "ORD-002", Amount: 99.99})

	if err := dispatcher.Dispatch(reg, ctx, Unknown{Foo: "bar"}); err != nil {
		fmt.Printf("Dispatch err: %v", err)
	}

	// Output:
	// Processing event: dispatcher_test.UserCreated
	// User created: Alice (ID: 1)
	// Successfully processed event: dispatcher_test.UserCreated
	// Processing event: dispatcher_test.OrderPlaced
	// Order placed: ORD-001 for $99.99
	// Successfully processed event: dispatcher_test.OrderPlaced
	// Processing event: dispatcher_test.UserCreated
	// User created: Alice (ID: 2)
	// Successfully processed event: dispatcher_test.UserCreated
	// Processing event: dispatcher_test.OrderPlaced
	// Order placed: ORD-002 for $99.99
	// Successfully processed event: dispatcher_test.OrderPlaced
	// Dispatch err: dispatcher: handler not found for type dispatcher_test.Unknown
}