fix: remain native codec

pkg/chart/linker.go

@@ -1,7 +1,7 @@
 package chart
 
 import (
-	"slices"
+	"sync"
 
 	"github.com/siyul-park/uniflow/pkg/hook"
 	"github.com/siyul-park/uniflow/pkg/node"
@@ -20,6 +20,8 @@ type LinkerConfig struct {
 type Linker struct {
 	hook   *hook.Hook
 	scheme *scheme.Scheme
+	codecs map[string]scheme.Codec
+	mu     sync.RWMutex
 }
 
 var _ LoadHook = (*Linker)(nil)
@@ -30,16 +32,22 @@ func NewLinker(config LinkerConfig) *Linker {
 	return &Linker{
 		hook:   config.Hook,
 		scheme: config.Scheme,
+		codecs: make(map[string]scheme.Codec),
 	}
 }
 
 // Load loads the chart, creating nodes and symbols.
 func (l *Linker) Load(chrt *Chart) error {
-	if slices.Contains(l.scheme.Kinds(), chrt.GetName()) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	kind := chrt.GetName()
+	codec := l.codecs[kind]
+	if l.scheme.Codec(kind) != codec {
 		return nil
 	}
 
-	codec := scheme.CodecFunc(func(sp spec.Spec) (node.Node, error) {
+	codec = scheme.CodecFunc(func(sp spec.Spec) (node.Node, error) {
 		specs, err := chrt.Build(sp)
 		if err != nil {
 			return nil, err
@@ -103,16 +111,25 @@ func (l *Linker) Load(chrt *Chart) error {
 		return n, nil
 	})
 
-	l.scheme.AddKnownType(chrt.GetName(), &spec.Unstructured{})
-	l.scheme.AddCodec(chrt.GetName(), codec)
-
+	l.scheme.AddKnownType(kind, &spec.Unstructured{})
+	l.scheme.AddCodec(kind, codec)
+	l.codecs[kind] = codec
 	return nil
 }
 
 // Unload removes the chart from the scheme.
 func (l *Linker) Unload(chrt *Chart) error {
-	l.scheme.RemoveKnownType(chrt.GetName())
-	l.scheme.RemoveCodec(chrt.GetName())
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	kind := chrt.GetName()
+	codec := l.codecs[kind]
+	if l.scheme.Codec(kind) != codec {
+		return nil
+	}
 
+	l.scheme.RemoveKnownType(kind)
+	l.scheme.RemoveCodec(kind)
+	delete(l.codecs, kind)
 	return nil
 }

pkg/chart/linker_test.go

@@ -88,10 +88,7 @@ func TestLinker_Unload(t *testing.T) {
 		Specs:     []spec.Spec{},
 	}
 
-	s.AddKnownType(chrt.GetName(), &spec.Meta{})
-	s.AddCodec(chrt.GetName(), scheme.CodecFunc(func(spec spec.Spec) (node.Node, error) {
-		return node.NewOneToOneNode(nil), nil
-	}))
+	l.Load(chrt)
 
 	err := l.Unload(chrt)
 	assert.NoError(t, err)

pkg/chart/table.go

@@ -72,6 +72,18 @@ func (t *Table) Lookup(id uuid.UUID) *Chart {
 	return t.charts[id]
 }
 
+// Links returns the charts linked to the chart specified by its UUID.
+func (t *Table) Links(id uuid.UUID) []*Chart {
+	t.mu.RLock()
+	defer t.mu.RUnlock()
+
+	chrt, ok := t.charts[id]
+	if !ok {
+		return nil
+	}
+	return t.linked(chrt)
+}
+
 // Keys returns all IDs of charts in the table.
 func (t *Table) Keys() []uuid.UUID {
 	t.mu.RLock()

pkg/chart/table_test.go

@@ -89,6 +89,39 @@ func TestTable_Lookup(t *testing.T) {
 	assert.Equal(t, chrt, tb.Lookup(chrt.GetID()))
 }
 
+func TestTable_Links(t *testing.T) {
+	tb := NewTable()
+	defer tb.Close()
+
+	chrt1 := &Chart{
+		ID:        uuid.Must(uuid.NewV7()),
+		Namespace: resource.DefaultNamespace,
+		Name:      faker.UUIDHyphenated(),
+		Specs:     []spec.Spec{},
+	}
+	chrt2 := &Chart{
+		ID:        uuid.Must(uuid.NewV7()),
+		Namespace: resource.DefaultNamespace,
+		Name:      faker.UUIDHyphenated(),
+		Specs: []spec.Spec{
+			&spec.Meta{
+				Kind:      chrt1.GetName(),
+				Namespace: resource.DefaultNamespace,
+				Name:      faker.UUIDHyphenated(),
+			},
+		},
+	}
+
+	tb.Insert(chrt1)
+	tb.Insert(chrt2)
+
+	links := tb.Links(chrt1.GetID())
+	assert.Equal(t, []*Chart{chrt1, chrt2}, links)
+
+	links = tb.Links(chrt2.GetID())
+	assert.Equal(t, []*Chart{chrt2}, links)
+}
+
 func TestTable_Keys(t *testing.T) {
 	tb := NewTable()
 	defer tb.Close()

pkg/runtime/runtime.go

@@ -20,9 +20,9 @@ type Config struct {
 	Namespace   string         // Namespace defines the isolated execution environment for workflows.
 	Hook        *hook.Hook     // Hook is a collection of hook functions for managing symbols.
 	Scheme      *scheme.Scheme // Scheme defines the scheme and behaviors for symbols.
-	ChartStore  chart.Store
-	SpecStore   spec.Store   // SpecStore is responsible for persisting specifications.
-	SecretStore secret.Store // SecretStore is responsible for persisting secrets.
+	ChartStore  chart.Store    // ChartStore is responsible for persisting charts.
+	SpecStore   spec.Store     // SpecStore is responsible for persisting specifications.
+	SecretStore secret.Store   // SecretStore is responsible for persisting secrets.
 }
 
 // Runtime represents an environment for executing Workflows.
@@ -183,35 +183,37 @@ func (r *Runtime) Reconcile(ctx context.Context) error {
 				return nil
 			}
 
-			charts, err := r.chartStore.Load(ctx, &chart.Chart{ID: event.ID})
-			if err != nil {
-				return err
-			}
+			charts := r.chartTable.Links(event.ID)
 			if len(charts) == 0 {
-				if chrt := r.chartTable.Lookup(event.ID); chrt != nil {
-					charts = append(charts, chrt)
-				} else {
-					charts = append(charts, &chart.Chart{ID: event.ID})
+				var err error
+				charts, err = r.chartStore.Load(ctx, &chart.Chart{ID: event.ID})
+				if err != nil {
+					return err
 				}
 			}
 
-			for _, chrt := range charts {
-				r.chartLoader.Load(ctx, chrt)
-			}
-
 			kinds := make([]string, 0, len(charts))
 			for _, chrt := range charts {
 				kinds = append(kinds, chrt.GetName())
 			}
 
+			bounded := make(map[uuid.UUID]spec.Spec)
 			for _, id := range r.symbolTable.Keys() {
 				sb := r.symbolTable.Lookup(id)
 				if sb != nil && slices.Contains(kinds, sb.Kind()) {
+					bounded[sb.ID()] = sb.Spec
 					r.symbolTable.Free(sb.ID())
-					unloaded[sb.ID()] = sb.Spec
 				}
 			}
 			for _, sp := range unloaded {
+				if slices.Contains(kinds, sp.GetKind()) {
+					bounded[sp.GetID()] = sp
+				}
+			}
+
+			r.chartLoader.Load(ctx, &chart.Chart{ID: event.ID})
+
+			for _, sp := range bounded {
 				if slices.Contains(kinds, sp.GetKind()) {
 					if err := r.symbolLoader.Load(ctx, sp); err != nil {
 						unloaded[sp.GetID()] = sp

pkg/runtime/runtime_test.go

@@ -40,7 +40,6 @@ func TestRuntime_Load(t *testing.T) {
 		SpecStore:   specStore,
 		SecretStore: secretStore,
 	})
-
 	defer r.Close()
 
 	meta := &spec.Meta{

pkg/scheme/codec.go

@@ -7,16 +7,24 @@ import (
 	"github.com/siyul-park/uniflow/pkg/spec"
 )
 
-// Codec defines the interface for decoding spec.Spec into a node.Node.
+// Codec defines the interface for converting a spec.Spec into a node.Node.
 type Codec interface {
-	// Compile compiles the given spec.Spec into a node.Node.
+	// Compile converts the given spec.Spec into a node.Node.
 	Compile(sp spec.Spec) (node.Node, error)
 }
 
-// CodecFunc represents a function type that implements the Codec interface.
-type CodecFunc func(sp spec.Spec) (node.Node, error)
+type codec struct {
+	compile func(sp spec.Spec) (node.Node, error)
+}
+
+var _ Codec = (*codec)(nil)
+
+// CodecFunc takes a compile function and returns a struct that implements the Codec interface.
+func CodecFunc(compile func(sp spec.Spec) (node.Node, error)) Codec {
+	return &codec{compile: compile}
+}
 
-// CodecWithType creates a new CodecFunc for the specified type T.
+// CodecWithType creates a Codec that works with a specific type T.
 func CodecWithType[T spec.Spec](compile func(spec T) (node.Node, error)) Codec {
 	return CodecFunc(func(spec spec.Spec) (node.Node, error) {
 		if converted, ok := spec.(T); ok {
@@ -26,7 +34,6 @@ func CodecWithType[T spec.Spec](compile func(spec T) (node.Node, error)) Codec {
 	})
 }
 
-// Compile implements the Compile method for CodecFunc.
-func (f CodecFunc) Compile(sp spec.Spec) (node.Node, error) {
-	return f(sp)
+func (c *codec) Compile(sp spec.Spec) (node.Node, error) {
+	return c.compile(sp)
 }