feat(command): use ShouldCaptureError func to capture command errors (#63)

* feat(command): turn CaptureErrors into a ShouldCaptureError function

* chore: add new entry to CHANGELOG

Author: ar3s3ru

CHANGELOG.md

@@ -14,6 +14,7 @@ project adheres to [Semantic Versioning](https://semver.org/).
 - Existing `Event-Id` value in Event Metadata does not get overwritten in correlation.EventStoreWrapper.
 - `postgres.EventStore` now uses the `Serde` interface for serializing to and deserializing from byte array.
 - `postgres.Registry` is now called `postgres.JSONRegistry` and implements thenew `postgres.Serde` interface.
+- `CaptureErrors` in `command.ErrorRecorder` is now a function (`ShouldCaptureError`), to allow for a more flexible capture strategy.
 
 ### Deprecated
 - ...

command/error_recorder.go

@@ -26,13 +26,13 @@ type ErrorRecorder struct {
 	// Appender is the Event Store instance used for appending domain events.
 	Appender eventstore.Appender
 
-	// CaptureErrors specifies whether an error reported from the
-	// command.Handler should be captured (or "silenced") by this component
-	// and return nil instead.
+	// ShouldCaptureError is a function that should specify
+	// whether an error reported from the command.Handler should be captured (or "silenced")
+	// by this component and avoid returning it to the command caller.
 	//
 	// Default behavior is to return all errors from the command.Handler
 	// to the caller.
-	CaptureErrors bool
+	ShouldCaptureError func(err error) bool
 
 	// StreamType specifies the stream type used for the events produced by this component.
 	// If unspecified, FailedCommandType will be used by default.
@@ -75,10 +75,10 @@ func (er ErrorRecorder) buildStreamID(cmd eventually.Command) stream.ID {
 // in case of failure, appends the error and command to the Event Store
 // using the user-provided EventMapper.
 //
-// If CaptureError has been set to "false", the error coming from the command.Handler
+// If ShouldCaptureError has been set and returns "false", the error coming from the command.Handler
 // will be returned to the caller.
 //
-// If CaptureError has been set to "true", the error from the command.Handler is silenced
+// If ShouldCaptureError has been set and returns "true", the error from the command.Handler is silenced
 // but an error can still be returned if the append operation on the Event Store fails.
 func (er ErrorRecorder) Handle(ctx context.Context, cmd eventually.Command) error {
 	err := er.Handler.Handle(ctx, cmd)
@@ -91,13 +91,18 @@ func (er ErrorRecorder) Handle(ctx context.Context, cmd eventually.Command) erro
 		Payload: er.EventMapper(err, cmd),
 	}
 
+	captureError := false
+	if er.ShouldCaptureError != nil {
+		captureError = er.ShouldCaptureError(err)
+	}
+
 	_, appendErr := er.Appender.Append(ctx, streamID, eventstore.VersionCheckAny, event)
-	if appendErr != nil && er.CaptureErrors {
+	if appendErr != nil && captureError {
 		// Append error only returned if silencing command.Handler errors.
 		return fmt.Errorf("command.ErrorRecorder: failed to append command error to event store: %w", err)
 	}
 
-	if !er.CaptureErrors {
+	if !captureError {
 		return fmt.Errorf("command.ErrorRecorder: command handler failed: %w", err)
 	}
 

command/error_recorder_test.go

@@ -99,7 +99,7 @@ func TestErrorRecorder(t *testing.T) {
 		}, trackingEventStore.Recorded())
 	})
 
-	t.Run("when handler fails and CaptureError is set to true, no error is returned", func(t *testing.T) {
+	t.Run("when handler fails and ShouldCaptureError returns true, no error is returned", func(t *testing.T) {
 		eventStore := inmemory.NewEventStore()
 		trackingEventStore := inmemory.NewTrackingEventStore(eventStore)
 
@@ -109,11 +109,13 @@ func TestErrorRecorder(t *testing.T) {
 		}
 
 		handler := command.ErrorRecorder{
-			CaptureErrors: true,
 			Handler: command.HandlerFunc(func(ctx context.Context, cmd eventually.Command) error {
 				return expectedErr
 			}),
 			Appender: trackingEventStore,
+			ShouldCaptureError: func(err error) bool {
+				return true
+			},
 			EventMapper: func(err error, cmd eventually.Command) eventually.Payload {
 				return mockCommandHasFailed{
 					err:     err,
@@ -142,6 +144,53 @@ func TestErrorRecorder(t *testing.T) {
 		}, trackingEventStore.Recorded())
 	})
 
+	t.Run("when handler fails and ShouldCaptureError returns false, error is returned to caller", func(t *testing.T) {
+		eventStore := inmemory.NewEventStore()
+		trackingEventStore := inmemory.NewTrackingEventStore(eventStore)
+
+		expectedErr := errors.New("failed command")
+		unexpectedErr := errors.New("unexpected error")
+
+		expectedCommand := eventually.Command{
+			Payload: mockCommand{message: t.Name()},
+		}
+
+		handler := command.ErrorRecorder{
+			Handler: command.HandlerFunc(func(ctx context.Context, cmd eventually.Command) error {
+				return expectedErr
+			}),
+			Appender: trackingEventStore,
+			ShouldCaptureError: func(err error) bool {
+				return errors.Is(err, unexpectedErr) // This will return false
+			},
+			EventMapper: func(err error, cmd eventually.Command) eventually.Payload {
+				return mockCommandHasFailed{
+					err:     err,
+					command: cmd.Payload.(mockCommand),
+				}
+			},
+		}
+
+		err := handler.Handle(context.Background(), expectedCommand)
+
+		assert.ErrorIs(t, err, expectedErr)
+		assert.Equal(t, []eventstore.Event{
+			{
+				Version: 1,
+				Stream: stream.ID{
+					Type: command.FailedType,
+					Name: expectedCommand.Payload.Name(),
+				},
+				Event: eventually.Event{
+					Payload: mockCommandHasFailed{
+						err:     expectedErr,
+						command: expectedCommand.Payload.(mockCommand),
+					},
+				},
+			},
+		}, trackingEventStore.Recorded())
+	})
+
 	t.Run("when handler fails, record event with custom stream type", func(t *testing.T) {
 		eventStore := inmemory.NewEventStore()
 		trackingEventStore := inmemory.NewTrackingEventStore(eventStore)