go-server-sdk/eval_hook_runner.go at main · DevCycleHQ/go-server-sdk · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
package devcycle

import (
	"fmt"

	"github.com/devcyclehq/go-server-sdk/v2/api"
	"github.com/devcyclehq/go-server-sdk/v2/util"
)

// BeforeHookError represents an error that occurred during a before hook
type BeforeHookError struct {
	HookIndex int
	Err       error
}

func (e *BeforeHookError) Error() string {
	return fmt.Sprintf("before hook %d failed: %v", e.HookIndex, e.Err)
}

func (e *BeforeHookError) Unwrap() error {
	return e.Err
}

// AfterHookError represents an error that occurred during an after hook
type AfterHookError struct {
	HookIndex int
	Err       error
}

func (e *AfterHookError) Error() string {
	return fmt.Sprintf("after hook %d failed: %v", e.HookIndex, e.Err)
}

func (e *AfterHookError) Unwrap() error {
	return e.Err
}

// EvalHookRunner manages and executes evaluation hooks
type EvalHookRunner struct {
	hooks []*EvalHook
}

// NewEvalHookRunner creates a new EvalHookRunner with the provided hooks
func NewEvalHookRunner(hooks []*EvalHook) *EvalHookRunner {
	return &EvalHookRunner{
		hooks: hooks,
	}
}

// RunBeforeHooks runs all before hooks in order
func (r *EvalHookRunner) RunBeforeHooks(hooks []*EvalHook, context *HookContext) error {
	if context == nil {
		return nil
	}
	for i, hook := range hooks {
		if hook.Before != nil {
			if err := hook.Before(context); err != nil {
				util.Errorf("Before hook %d failed: %v", i, err)
				return &BeforeHookError{HookIndex: i, Err: err}
			}
		}
	}
	return nil
}

// RunAfterHooks runs all after hooks in reverse order
func (r *EvalHookRunner) RunAfterHooks(hooks []*EvalHook, context *HookContext, variable api.Variable, metadata VariableMetadata) error {
	if context == nil {
		return nil
	}
	for i := len(hooks) - 1; i >= 0; i-- {
		hook := hooks[i]
		if hook.After != nil {
			if err := hook.After(context, &variable, &metadata); err != nil {
				util.Errorf("After hook %d failed: %v", i, err)
				return &AfterHookError{HookIndex: i, Err: err}
			}
		}
	}
	return nil
}

// RunOnFinallyHooks runs all onFinally hooks in reverse order
func (r *EvalHookRunner) RunOnFinallyHooks(hooks []*EvalHook, context *HookContext, variable api.Variable, metadata VariableMetadata) {
	if context == nil {
		return
	}
	for i := len(hooks) - 1; i >= 0; i-- {
		hook := hooks[i]
		if hook.OnFinally != nil {
			if err := hook.OnFinally(context, &variable, &metadata); err != nil {
				util.Errorf("OnFinally hook %d failed: %v", i, err)
			}
		}
	}
}

// RunErrorHooks runs all error hooks in reverse order
func (r *EvalHookRunner) RunErrorHooks(hooks []*EvalHook, context *HookContext, evalError error) {
	if context == nil {
		return
	}
	for i := len(hooks) - 1; i >= 0; i-- {
		hook := hooks[i]
		if hook.Error != nil {
			if err := hook.Error(context, evalError); err != nil {
				util.Errorf("Error hook %d failed: %v", i, err)
			}
		}
	}
}

func (r *EvalHookRunner) AddHook(hook *EvalHook) {
	r.hooks = append(r.hooks, hook)
}

func (r *EvalHookRunner) ClearHooks() {
	r.hooks = []*EvalHook{}
}