fix: make dep type dynamic

Author: graham-chainlink

operations/operation.go

@@ -67,6 +67,11 @@ func (o *Operation[IN, OUT, DEP]) Description() string {
 	return o.def.Description
 }
 
+// Def returns the operation definition.
+func (o *Operation[IN, OUT, DEP]) Def() Definition {
+	return o.def
+}
+
 // execute runs the operation by calling the OperationHandler.
 func (o *Operation[IN, OUT, DEP]) execute(b Bundle, deps DEP, input IN) (output OUT, err error) {
 	b.Logger.Infow("Executing operation",
@@ -78,14 +83,14 @@ func (o *Operation[IN, OUT, DEP]) execute(b Bundle, deps DEP, input IN) (output
 // 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]{
+func (o *Operation[IN, OUT, DEP]) AsUntyped() *Operation[any, any, any] {
+	return &Operation[any, any, any]{
 		def: Definition{
 			ID:          o.def.ID,
 			Version:     o.def.Version,
 			Description: o.def.Description,
 		},
-		handler: func(b Bundle, deps DEP, input any) (any, error) {
+		handler: func(b Bundle, deps any, input any) (any, error) {
 			var typedInput IN
 			if input != nil {
 				var ok bool
@@ -94,7 +99,15 @@ func (o *Operation[IN, OUT, DEP]) AsUntyped() *Operation[any, any, DEP] {
 				}
 			}
 
-			return o.execute(b, deps, typedInput)
+			var typedDeps DEP
+			if deps != nil {
+				var ok bool
+				if typedDeps, ok = deps.(DEP); !ok {
+					return nil, errors.New("dependencies type mismatch")
+				}
+			}
+
+			return o.execute(b, typedDeps, typedInput)
 		},
 	}
 }

operations/operation_test.go

@@ -32,6 +32,7 @@ func Test_NewOperation(t *testing.T) {
 	assert.Equal(t, "sum", op.ID())
 	assert.Equal(t, version.String(), op.Version())
 	assert.Equal(t, description, op.Description())
+	assert.Equal(t, op.def, op.Def())
 	res, err := op.handler(Bundle{}, OpDeps{}, OpInput{1, 2})
 	require.NoError(t, err)
 	assert.Equal(t, 3, res)
@@ -106,7 +107,7 @@ func Test_Operation_AsUntyped(t *testing.T) {
 	// Table-driven test cases
 	tests := []struct {
 		name        string
-		deps        OpDeps
+		deps        any
 		input       any
 		wantResult  any
 		wantErr     bool
@@ -126,6 +127,13 @@ func Test_Operation_AsUntyped(t *testing.T) {
 			wantErr:     true,
 			errContains: "input type mismatch",
 		},
+		{
+			name:        "invalid dependencies type",
+			deps:        "invalid",
+			input:       OpInput{A: 1, B: 2},
+			wantErr:     true,
+			errContains: "dependencies type mismatch",
+		},
 	}
 
 	for _, tt := range tests {

operations/registry.go

@@ -3,25 +3,26 @@ 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]
+type OperationRegistry struct {
+	Ops []*Operation[any, any, any]
 }
 
 // NewOperationRegistry creates a new OperationRegistry with the provided untyped operations.
-func NewOperationRegistry[DEP any](ops ...*Operation[any, any, DEP]) OperationRegistry[DEP] {
-	return OperationRegistry[DEP]{
+func NewOperationRegistry(ops ...*Operation[any, any, any]) OperationRegistry {
+	return OperationRegistry{
 		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) {
+func (s OperationRegistry) Retrieve(def Definition) (*Operation[any, any, any], 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

@@ -14,12 +14,15 @@ import (
 // ExampleOperationRegistry demonstrates how to create and use an OperationRegistry
 // with operations being executed dynamically with different input/output types.
 func ExampleOperationRegistry() {
+	type Deps1 struct{}
+	type Deps2 struct{}
+
 	// 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) {
+		func(e Bundle, deps Deps1, input string) (string, error) {
 			return input, nil
 		},
 	)
@@ -28,7 +31,7 @@ func ExampleOperationRegistry() {
 		"int-op",
 		semver.MustParse("1.0.0"),
 		"Echo integer operation",
-		func(e Bundle, deps OpDeps, input int) (int, error) {
+		func(e Bundle, deps Deps2, input int) (int, error) {
 			return input, nil
 		},
 	)
@@ -39,6 +42,7 @@ func ExampleOperationRegistry() {
 	b := NewBundle(context.Background, logger.Nop(), NewMemoryReporter())
 
 	inputs := []any{"input1", 42}
+	deps := []any{Deps1{}, Deps2{}}
 	defs := []Definition{
 		{ID: "string-op", Version: semver.MustParse("1.0.0")},
 		{ID: "int-op", Version: semver.MustParse("1.0.0")},
@@ -52,7 +56,11 @@ func ExampleOperationRegistry() {
 			continue
 		}
 
-		report, err := ExecuteOperation(b, retrievedOp, OpDeps{}, inputs[i])
+		report, err := ExecuteOperation(b, retrievedOp, deps[i], inputs[i])
+		if err != nil {
+			fmt.Println("error executing operation:", err)
+			continue
+		}
 
 		fmt.Println("operation output:", report.Output)
 	}