type_adapter_action.go

package chain

import "context"

// InternalTypeGetter extracts a subpart (U) from a composite data structure (T).
// It allows access to a part of the structure without modifying the entire one.
type InternalTypeGetter[T any, U any] func(T) U

// ExternalTypeSetter updates a composite data structure (T) with a new subpart (U).
// It returns the updated composite value.
type ExternalTypeSetter[T any, U any] func(T, U) T

// AdaptAction creates an Action that works with a composite data structure (T),
// where T is a complex type (e.g., a struct with multiple fields) and U is the
// data type that the Action operates on. The InternalTypeGetter and ExternalTypeSetter
// functions extract U from T and write the processed result back into T.
func AdaptAction[T any, U any](
	action Action[U],
	getter InternalTypeGetter[T, U],
	setter ExternalTypeSetter[T, U],
) Action[T] {
	if action == nil {
		panic("action cannot be nil")
	} else if getter == nil {
		panic("getter cannot be nil")
	} else if setter == nil {
		panic("setter cannot be nil")
	}

	return &typeAdapterAction[T, U]{
		action: action,
		getter: getter,
		setter: setter,
	}
}

type typeAdapterAction[T any, U any] struct {
	action Action[U]
	getter InternalTypeGetter[T, U]
	setter ExternalTypeSetter[T, U]
}

func (a typeAdapterAction[T, U]) Name() string { return a.action.Name() }
func (a typeAdapterAction[T, U]) Run(ctx context.Context, input T) (output T, err error) {
	output = input

	actualInput := a.getter(input)
	actualOutput, err := a.action.Run(ctx, actualInput)
	output = a.setter(output, actualOutput)

	return output, err
}