feat: resolve by token

Author: 4strodev

pkg/container/container.go

@@ -11,14 +11,16 @@ import (
 
 type Container struct {
 	graph.Graph[resolver.DependencyResolver[any]]
-	typeIndex map[reflect.Type]*graph.Node[resolver.DependencyResolver[any]]
-	connected bool
+	typeIndex  map[reflect.Type]*graph.Node[resolver.DependencyResolver[any]]
+	tokenIndex map[string]*graph.Node[resolver.DependencyResolver[any]]
+	connected  bool
 }
 
 func New() *Container {
 	return &Container{
-		Graph:     graph.NewGraph[resolver.DependencyResolver[any]](),
-		typeIndex: make(map[reflect.Type]*graph.Node[resolver.DependencyResolver[any]]),
+		Graph:      graph.NewGraph[resolver.DependencyResolver[any]](),
+		typeIndex:  make(map[reflect.Type]*graph.Node[resolver.DependencyResolver[any]]),
+		tokenIndex: make(map[string]*graph.Node[resolver.DependencyResolver[any]]),
 	}
 }
 
@@ -45,6 +47,28 @@ func (c *Container) AddDependency(res any) error {
 	return nil
 }
 
+func (c *Container) AddTokenDependency(token string, res any) error {
+	c.connected = false
+	if !resolver.IsValid(res) {
+		return errors.New("invalid resolver")
+	}
+
+	builder := resolver.DependencyResolver[any]{
+		Resolver: res,
+	}
+
+	_, exists := c.tokenIndex[token]
+	if exists {
+		return fmt.Errorf("dependency for token type already exists: %s", token)
+	}
+
+	node := graph.NewNode(builder)
+	c.Add(node)
+	c.tokenIndex[token] = node
+
+	return nil
+}
+
 func (c *Container) AddDependencies(resolvers ...any) error {
 	c.connected = false
 	for _, res := range resolvers {
@@ -157,3 +181,26 @@ func (c Container) resolve(t reflect.Type) (resolvedValue reflect.Value, err err
 
 	return resolver.Execute(dependencyResolver, inputArgs)
 }
+
+func (c Container) resolveToken(token string) (resolvedValue reflect.Value, err error) {
+	node, ok := c.tokenIndex[token]
+	if !ok {
+		err = fmt.Errorf("dependency not found for token %s", token)
+		return
+	}
+
+	dependencyResolver := node.Val
+	inputTypes := dependencyResolver.Input()
+	inputArgs := []reflect.Value{}
+
+	for _, inputType := range inputTypes {
+		arg, err := c.resolve(inputType)
+		if err != nil {
+			return resolvedValue, err
+		}
+
+		inputArgs = append(inputArgs, arg)
+	}
+
+	return resolver.Execute(dependencyResolver, inputArgs)
+}

pkg/container/container_test.go

@@ -84,3 +84,18 @@ func TestFill(t *testing.T) {
 	err = cont.Fill(&deps)
 	require.NoError(t, err, "struct should be filled correctly")
 }
+
+func TestResolveToken(t *testing.T) {
+	cont := container.New()
+
+	dependantResolver := func() *bytes.Buffer {
+		return bytes.NewBuffer([]byte{})
+	}
+
+	err := cont.AddTokenDependency("buffer", dependantResolver)
+	require.NoError(t, err)
+
+	buf, err := container.ResolveToken[*bytes.Buffer](cont, "buffer")
+	require.NoError(t, err)
+	require.NotNil(t, buf)
+}

pkg/container/resolve.go

@@ -25,3 +25,24 @@ func Resolve[T any](c *Container) (T, error) {
 
 	return dependency, err
 }
+
+func ResolveToken[T any](c *Container, token string) (T, error) {
+	var dependency T
+	_, err := c.DetectCircularDependencies()
+	if err != nil {
+		return dependency, err
+	}
+
+	resolvedValue, err := c.resolveToken(token)
+	if err != nil {
+		return dependency, err
+	}
+
+	var ok bool
+	dependency, ok = resolvedValue.Interface().(T)
+	if !ok {
+		err = fmt.Errorf("cannot convert returned value into %s", reflect.TypeFor[T]().String())
+	}
+
+	return dependency, err
+}