protyping on dynamic operation execution

Author: graham-chainlink

operations/operation.go

@@ -2,6 +2,7 @@ package operations
 
 import (
 	"context"
+	"errors"
 	"sync"
 
 	"github.com/Masterminds/semver/v3"
@@ -74,6 +75,30 @@ func (o *Operation[IN, OUT, DEP]) execute(b Bundle, deps DEP, input IN) (output
 	return o.handler(b, deps, input)
 }
 
+// AsUntyped converts the operation to an untyped operation.
+// This is useful for storing operations in a slice or passing them around without type constraints.
+// Warning: The input and output types will be converted to `any`, so type safety is lost.
+func (o *Operation[IN, OUT, DEP]) AsUntyped() *Operation[any, any, DEP] {
+	return &Operation[any, any, DEP]{
+		def: Definition{
+			ID:          o.def.ID,
+			Version:     o.def.Version,
+			Description: o.def.Description,
+		},
+		handler: func(b Bundle, deps DEP, input any) (any, error) {
+			var typedInput IN
+			if input != nil {
+				var ok bool
+				if typedInput, ok = input.(IN); !ok {
+					return nil, errors.New("input type mismatch")
+				}
+			}
+
+			return o.execute(b, deps, typedInput)
+		},
+	}
+}
+
 // NewOperation creates a new operation.
 // Version can be created using semver.MustParse("1.0.0") or semver.New("1.0.0").
 // Note: The handler should only perform maximum 1 side effect.

operations/operation_test.go

@@ -82,3 +82,64 @@ func Test_Operation_WithEmptyInput(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, 1, out)
 }
+
+func Test_Operation_AsUntyped(t *testing.T) {
+	t.Parallel()
+
+	// Create a typed operation
+	version := semver.MustParse("1.0.0")
+	description := "test operation"
+	handler1 := func(b Bundle, deps OpDeps, input OpInput) (output int, err error) {
+		return input.A + input.B, nil
+	}
+	typedOp := NewOperation("sum", version, description, handler1)
+
+	// Convert to untyped operation
+	untypedOp := typedOp.AsUntyped()
+	bundle := NewBundle(context.Background, logger.Test(t), nil)
+
+	// Test definition fields are preserved
+	assert.Equal(t, "sum", untypedOp.ID())
+	assert.Equal(t, version.String(), untypedOp.Version())
+	assert.Equal(t, description, untypedOp.Description())
+
+	// Table-driven test cases
+	tests := []struct {
+		name        string
+		deps        OpDeps
+		input       any
+		wantResult  any
+		wantErr     bool
+		errContains string
+	}{
+		{
+			name:       "valid input and dependencies",
+			deps:       OpDeps{},
+			input:      OpInput{A: 3, B: 4},
+			wantResult: 7,
+			wantErr:    false,
+		},
+		{
+			name:        "invalid input type",
+			deps:        OpDeps{},
+			input:       struct{ C int }{C: 5},
+			wantErr:     true,
+			errContains: "input type mismatch",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			result, err := untypedOp.handler(bundle, tt.deps, tt.input)
+
+			if tt.wantErr {
+				require.Error(t, err)
+				assert.Contains(t, err.Error(), tt.errContains)
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tt.wantResult, result)
+			}
+		})
+	}
+}

operations/registry.go

@@ -0,0 +1,27 @@
+package operations
+
+import "errors"
+
+// OperationRegistry is a store for operations that allows retrieval based on their definitions.
+type OperationRegistry[DEP any] struct {
+	Ops []*Operation[any, any, DEP]
+}
+
+// NewOperationRegistry creates a new OperationRegistry with the provided untyped operations.
+func NewOperationRegistry[DEP any](ops ...*Operation[any, any, DEP]) OperationRegistry[DEP] {
+	return OperationRegistry[DEP]{
+		Ops: ops,
+	}
+}
+
+// Retrieve retrieves an operation from the store based on its definition.
+// It returns an error if the operation is not found.
+// The definition must match the operation's ID and version.
+func (s OperationRegistry[DEP]) Retrieve(def Definition) (*Operation[any, any, DEP], error) {
+	for _, op := range s.Ops {
+		if op.ID() == def.ID && op.Version() == def.Version.String() {
+			return op, nil
+		}
+	}
+	return nil, errors.New("operation not found in registry")
+}

operations/registry_test.go

@@ -0,0 +1,136 @@
+package operations
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/Masterminds/semver/v3"
+	"github.com/smartcontractkit/chainlink-common/pkg/logger"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// ExampleOperationRegistry demonstrates how to create and use an OperationRegistry
+// with operations being executed dynamically with different input/output types.
+func ExampleOperationRegistry() {
+	// Create operations with different input/output types
+	stringOp := NewOperation(
+		"string-op",
+		semver.MustParse("1.0.0"),
+		"Echo string operation",
+		func(e Bundle, deps OpDeps, input string) (string, error) {
+			return input, nil
+		},
+	)
+
+	intOp := NewOperation(
+		"int-op",
+		semver.MustParse("1.0.0"),
+		"Echo integer operation",
+		func(e Bundle, deps OpDeps, input int) (int, error) {
+			return input, nil
+		},
+	)
+	// Create registry with untyped operations
+	registry := NewOperationRegistry(stringOp.AsUntyped(), intOp.AsUntyped())
+
+	// Create execution environment
+	b := NewBundle(context.Background, logger.Nop(), NewMemoryReporter())
+
+	inputs := []any{"input1", 42}
+	defs := []Definition{
+		{ID: "string-op", Version: semver.MustParse("1.0.0")},
+		{ID: "int-op", Version: semver.MustParse("1.0.0")},
+	}
+
+	// dynamically retrieve and execute operations on different inputs
+	for i, def := range defs {
+		retrievedOp, err := registry.Retrieve(def)
+		if err != nil {
+			fmt.Println("error retrieving operation:", err)
+			continue
+		}
+
+		report, err := ExecuteOperation(b, retrievedOp, OpDeps{}, inputs[i])
+
+		fmt.Println("operation output:", report.Output)
+	}
+
+	// Output:
+	// operation output: input1
+	// operation output: 42
+}
+
+func TestOperationRegistry(t *testing.T) {
+	t.Parallel()
+
+	// Test fixture setup
+	op1 := NewOperation(
+		"test-op-1",
+		semver.MustParse("1.0.0"),
+		"Operation 1",
+		func(e Bundle, deps OpDeps, input string) (string, error) { return input, nil },
+	)
+	op2 := NewOperation(
+		"test-op-2",
+		semver.MustParse("2.0.0"),
+		"Operation 2",
+		func(e Bundle, deps OpDeps, input int) (int, error) { return input * 2, nil },
+	)
+
+	tests := []struct {
+		name        string
+		operations  []*Operation[any, any, OpDeps]
+		lookup      Definition
+		wantErr     bool
+		wantErrMsg  string
+		wantID      string
+		wantVersion string
+	}{
+		{
+			name:        "retrieval by exact match - first operation",
+			lookup:      Definition{ID: "test-op-1", Version: semver.MustParse("1.0.0")},
+			wantErr:     false,
+			wantID:      "test-op-1",
+			wantVersion: "1.0.0",
+		},
+		{
+			name:        "retrieval by exact match - second operation",
+			lookup:      Definition{ID: "test-op-2", Version: semver.MustParse("2.0.0")},
+			wantErr:     false,
+			wantID:      "test-op-2",
+			wantVersion: "2.0.0",
+		},
+		{
+			name:       "operation not found - non-existent ID",
+			lookup:     Definition{ID: "non-existent", Version: semver.MustParse("1.0.0")},
+			wantErr:    true,
+			wantErrMsg: "operation not found in registry",
+		},
+		{
+			name:       "operation not found - wrong version",
+			lookup:     Definition{ID: "test-op-1", Version: semver.MustParse("3.0.0")},
+			wantErr:    true,
+			wantErrMsg: "operation not found in registry",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			registry := NewOperationRegistry(op1.AsUntyped(), op2.AsUntyped())
+			retrievedOp, err := registry.Retrieve(tt.lookup)
+
+			if tt.wantErr {
+				require.Error(t, err)
+				assert.ErrorContains(t, err, tt.wantErrMsg)
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tt.wantID, retrievedOp.ID())
+				assert.Equal(t, tt.wantVersion, retrievedOp.Version())
+			}
+		})
+	}
+}