mirror of
https://github.com/bitechdev/ResolveSpec.git
synced 2026-04-04 23:22:21 +00:00
114 lines
2.8 KiB
Go
114 lines
2.8 KiB
Go
package resolvemcp
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
"github.com/bitechdev/ResolveSpec/pkg/common"
|
|
"github.com/bitechdev/ResolveSpec/pkg/logger"
|
|
)
|
|
|
|
// HookType defines the type of hook to execute
|
|
type HookType string
|
|
|
|
const (
|
|
// BeforeHandle fires after model resolution, before operation dispatch.
|
|
BeforeHandle HookType = "before_handle"
|
|
|
|
BeforeRead HookType = "before_read"
|
|
AfterRead HookType = "after_read"
|
|
|
|
BeforeCreate HookType = "before_create"
|
|
AfterCreate HookType = "after_create"
|
|
|
|
BeforeUpdate HookType = "before_update"
|
|
AfterUpdate HookType = "after_update"
|
|
|
|
BeforeDelete HookType = "before_delete"
|
|
AfterDelete HookType = "after_delete"
|
|
)
|
|
|
|
// HookContext contains all the data available to a hook
|
|
type HookContext struct {
|
|
Context context.Context
|
|
Handler *Handler
|
|
Schema string
|
|
Entity string
|
|
Model interface{}
|
|
Options common.RequestOptions
|
|
Operation string
|
|
ID string
|
|
Data interface{}
|
|
Result interface{}
|
|
Error error
|
|
Query common.SelectQuery
|
|
Abort bool
|
|
AbortMessage string
|
|
AbortCode int
|
|
Tx common.Database
|
|
}
|
|
|
|
// HookFunc is the signature for hook functions
|
|
type HookFunc func(*HookContext) error
|
|
|
|
// HookRegistry manages all registered hooks
|
|
type HookRegistry struct {
|
|
hooks map[HookType][]HookFunc
|
|
}
|
|
|
|
func NewHookRegistry() *HookRegistry {
|
|
return &HookRegistry{
|
|
hooks: make(map[HookType][]HookFunc),
|
|
}
|
|
}
|
|
|
|
func (r *HookRegistry) Register(hookType HookType, hook HookFunc) {
|
|
if r.hooks == nil {
|
|
r.hooks = make(map[HookType][]HookFunc)
|
|
}
|
|
r.hooks[hookType] = append(r.hooks[hookType], hook)
|
|
logger.Info("Registered resolvemcp hook for %s (total: %d)", hookType, len(r.hooks[hookType]))
|
|
}
|
|
|
|
func (r *HookRegistry) RegisterMultiple(hookTypes []HookType, hook HookFunc) {
|
|
for _, hookType := range hookTypes {
|
|
r.Register(hookType, hook)
|
|
}
|
|
}
|
|
|
|
func (r *HookRegistry) Execute(hookType HookType, ctx *HookContext) error {
|
|
hooks, exists := r.hooks[hookType]
|
|
if !exists || len(hooks) == 0 {
|
|
return nil
|
|
}
|
|
|
|
logger.Debug("Executing %d resolvemcp hook(s) for %s", len(hooks), hookType)
|
|
|
|
for i, hook := range hooks {
|
|
if err := hook(ctx); err != nil {
|
|
logger.Error("resolvemcp hook %d for %s failed: %v", i+1, hookType, err)
|
|
return fmt.Errorf("hook execution failed: %w", err)
|
|
}
|
|
|
|
if ctx.Abort {
|
|
logger.Warn("resolvemcp hook %d for %s requested abort: %s", i+1, hookType, ctx.AbortMessage)
|
|
return fmt.Errorf("operation aborted by hook: %s", ctx.AbortMessage)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (r *HookRegistry) Clear(hookType HookType) {
|
|
delete(r.hooks, hookType)
|
|
}
|
|
|
|
func (r *HookRegistry) ClearAll() {
|
|
r.hooks = make(map[HookType][]HookFunc)
|
|
}
|
|
|
|
func (r *HookRegistry) HasHooks(hookType HookType) bool {
|
|
hooks, exists := r.hooks[hookType]
|
|
return exists && len(hooks) > 0
|
|
}
|