diff --git a/pkg/engine/mutate/expression.go b/pkg/engine/mutate/expression.go
deleted file mode 100644
index 4949a6f9..00000000
--- a/pkg/engine/mutate/expression.go
+++ /dev/null
@@ -1,65 +0,0 @@
-package mutate
-
-import (
- "context"
- "reflect"
- "regexp"
-
- reflectutils "github.com/kyverno/kyverno-json/pkg/utils/reflect"
-)
-
-var (
- foreachRegex = regexp.MustCompile(`^~(\w+)?\.(.*)`)
- bindingRegex = regexp.MustCompile(`(.*)\s*->\s*(\w+)$`)
- escapeRegex = regexp.MustCompile(`^\\(.+)\\$`)
- engineRegex = regexp.MustCompile(`^\((?:(\w+):)?(.+)\)$`)
-)
-
-type expression struct {
- foreach bool
- foreachName string
- statement string
- binding string
- engine string
-}
-
-func parseExpressionRegex(ctx context.Context, in string) *expression {
- expression := &expression{}
- // 1. match foreach
- if match := foreachRegex.FindStringSubmatch(in); match != nil {
- expression.foreach = true
- expression.foreachName = match[1]
- in = match[2]
- }
- // 2. match binding
- if match := bindingRegex.FindStringSubmatch(in); match != nil {
- expression.binding = match[2]
- in = match[1]
- }
- // 3. match escape, if there's no escaping then match engine
- if match := escapeRegex.FindStringSubmatch(in); match != nil {
- in = match[1]
- } else {
- if match := engineRegex.FindStringSubmatch(in); match != nil {
- expression.engine = match[1]
- // account for default engine
- if expression.engine == "" {
- expression.engine = "jp"
- }
- in = match[2]
- }
- }
- // parse statement
- expression.statement = in
- if expression.statement == "" {
- return nil
- }
- return expression
-}
-
-func parseExpression(ctx context.Context, value any) *expression {
- if reflectutils.GetKind(value) != reflect.String {
- return nil
- }
- return parseExpressionRegex(ctx, reflect.ValueOf(value).String())
-}
diff --git a/pkg/engine/mutate/mutate.go b/pkg/engine/mutate/mutate.go
deleted file mode 100644
index 9224e4a5..00000000
--- a/pkg/engine/mutate/mutate.go
+++ /dev/null
@@ -1,13 +0,0 @@
-package mutate
-
-import (
- "context"
-
- "github.com/jmespath-community/go-jmespath/pkg/binding"
- "github.com/kyverno/kyverno-json/pkg/engine/template"
- "k8s.io/apimachinery/pkg/util/validation/field"
-)
-
-func Mutate(ctx context.Context, path *field.Path, mutation Mutation, value any, bindings binding.Bindings, opts ...template.Option) (any, error) {
- return mutation.mutate(ctx, path, value, bindings, opts...)
-}
diff --git a/pkg/engine/mutate/mutation.go b/pkg/engine/mutate/mutation.go
deleted file mode 100644
index b712f1d1..00000000
--- a/pkg/engine/mutate/mutation.go
+++ /dev/null
@@ -1,13 +0,0 @@
-package mutate
-
-import (
- "context"
-
- "github.com/jmespath-community/go-jmespath/pkg/binding"
- "github.com/kyverno/kyverno-json/pkg/engine/template"
- "k8s.io/apimachinery/pkg/util/validation/field"
-)
-
-type Mutation interface {
- mutate(context.Context, *field.Path, any, binding.Bindings, ...template.Option) (any, error)
-}
diff --git a/pkg/engine/mutate/parse.go b/pkg/engine/mutate/parse.go
deleted file mode 100644
index 2b8e1b4d..00000000
--- a/pkg/engine/mutate/parse.go
+++ /dev/null
@@ -1,112 +0,0 @@
-package mutate
-
-import (
- "context"
- "fmt"
- "reflect"
-
- "github.com/jmespath-community/go-jmespath/pkg/binding"
- "github.com/kyverno/kyverno-json/pkg/engine/template"
- reflectutils "github.com/kyverno/kyverno-json/pkg/utils/reflect"
- "k8s.io/apimachinery/pkg/util/validation/field"
-)
-
-func Parse(ctx context.Context, mutation any) Mutation {
- switch reflectutils.GetKind(mutation) {
- case reflect.Slice:
- node := sliceNode{}
- valueOf := reflect.ValueOf(mutation)
- for i := 0; i < valueOf.Len(); i++ {
- node = append(node, Parse(ctx, valueOf.Index(i).Interface()))
- }
- return node
- case reflect.Map:
- node := mapNode{}
- iter := reflect.ValueOf(mutation).MapRange()
- for iter.Next() {
- node[iter.Key().Interface()] = Parse(ctx, iter.Value().Interface())
- }
- return node
- default:
- return &scalarNode{rhs: mutation}
- }
-}
-
-// mapNode is the mutation type represented by a map.
-// it is responsible for projecting the analysed resource and passing the result to the descendant
-type mapNode map[any]Mutation
-
-func (n mapNode) mutate(ctx context.Context, path *field.Path, value any, bindings binding.Bindings, opts ...template.Option) (any, error) {
- out := map[any]any{}
- for k, v := range n {
- var projection any
- if value != nil {
- mapValue := reflect.ValueOf(value).MapIndex(reflect.ValueOf(k))
- if mapValue.IsValid() {
- projection = mapValue.Interface()
- }
- }
- inner, err := v.mutate(ctx, path.Child(fmt.Sprint(k)), projection, bindings, opts...)
- if err != nil {
- return nil, err
- }
- out[k] = inner
- }
- return out, nil
-}
-
-// sliceNode is the mutation type represented by a slice.
-// it first compares the length of the analysed resource with the length of the descendants.
-// if lengths match all descendants are evaluated with their corresponding items.
-type sliceNode []Mutation
-
-func (n sliceNode) mutate(ctx context.Context, path *field.Path, value any, bindings binding.Bindings, opts ...template.Option) (any, error) {
- if value != nil && reflectutils.GetKind(value) != reflect.Slice && reflectutils.GetKind(value) != reflect.Array {
- return nil, field.TypeInvalid(path, value, "expected a slice or array")
- } else {
- var out []any
- for i := range n {
- var projection any
- if value != nil {
- valueOf := reflect.ValueOf(value)
- if i < valueOf.Len() {
- projection = valueOf.Index(i).Interface()
- }
- }
- inner, err := n[i].mutate(ctx, path.Index(i), projection, bindings, opts...)
- if err != nil {
- return nil, err
- }
- out = append(out, inner)
- }
- return out, nil
- }
-}
-
-// scalarNode is a terminal type of mutation.
-// it receives a value and compares it with an expected value.
-// the expected value can be the result of an expression.
-type scalarNode struct {
- rhs any
-}
-
-func (n *scalarNode) mutate(ctx context.Context, path *field.Path, value any, bindings binding.Bindings, opts ...template.Option) (any, error) {
- rhs := n.rhs
- expression := parseExpression(ctx, rhs)
- // we only project if the expression uses the engine syntax
- // this is to avoid the case where the value is a map and the RHS is a string
- if expression != nil && expression.engine != "" {
- if expression.foreachName != "" {
- return nil, field.Invalid(path, rhs, "foreach is not supported on the RHS")
- }
- if expression.binding != "" {
- return nil, field.Invalid(path, rhs, "binding is not supported on the RHS")
- }
- projected, err := template.Execute(ctx, expression.statement, value, bindings, opts...)
- if err != nil {
- return nil, field.InternalError(path, err)
- }
- rhs = projected
- }
- return rhs, nil
-}
diff --git a/pkg/engine/mutate/project.go b/pkg/engine/mutate/project.go
deleted file mode 100644
index b3f0f60d..00000000
--- a/pkg/engine/mutate/project.go
+++ /dev/null
@@ -1,63 +0,0 @@
-package mutate
-
-// import (
-// "context"
-// "reflect"
-
-// "github.com/jmespath-community/go-jmespath/pkg/binding"
-// "github.com/kyverno/kyverno-json/pkg/engine/template"
-// reflectutils "github.com/kyverno/kyverno-json/pkg/utils/reflect"
-// )
-
-// type projection struct {
-// foreach bool
-// foreachName string
-// binding string
-// result any
-// }
-
-// func project(ctx context.Context, key any, value any, bindings binding.Bindings, opts ...template.Option) (*projection, error) {
-// expression := parseExpression(ctx, key)
-// if expression != nil {
-// if expression.engine != "" {
-// projected, err := template.Execute(ctx, expression.statement, value, bindings, opts...)
-// if err != nil {
-// return nil, err
-// }
-// return &projection{
-// foreach: expression.foreach,
-// foreachName: expression.foreachName,
-// binding: expression.binding,
-// result: projected,
-// }, nil
-// } else {
-// if reflectutils.GetKind(value) == reflect.Map {
-// mapValue := reflect.ValueOf(value).MapIndex(reflect.ValueOf(expression.statement))
-// var value any
-// if mapValue.IsValid() {
-// value = mapValue.Interface()
-// }
-// return &projection{
-// foreach: expression.foreach,
-// foreachName: expression.foreachName,
-// binding: expression.binding,
-// result: value,
-// }, nil
-// }
-// }
-// }
-// if reflectutils.GetKind(value) == reflect.Map {
-// mapValue := reflect.ValueOf(value).MapIndex(reflect.ValueOf(key))
-// var value any
-// if mapValue.IsValid() {
-// value = mapValue.Interface()
-// }
-// return &projection{
-// result: value,
-// }, nil
-// }
-// // TODO is this an error ?
-// return &projection{
-// result: value,
-// }, nil
-// }