feat(factory): add factory package

pkg/factory/config.go

@@ -0,0 +1,37 @@
+package factory
+
+// Config is an interface that defines methods for creating and validating configurations.
+type Config interface {
+	// Validate the configuration and returns an error if invalid.
+	Validate() error
+}
+
+// NewConfigFunc is a function that creates a new config.
+type NewConfigFunc func() Config
+
+// ConfigFactory is a factory that creates a new config.
+type ConfigFactory interface {
+	Named
+	New() Config
+}
+
+// configFactory is a factory that implements the ConfigFactory interface.
+type configFactory struct {
+	name          Name
+	newConfigFunc NewConfigFunc
+}
+
+// Name returns the name of the factory.
+func (factory *configFactory) Name() Name {
+	return factory.name
+}
+
+// New creates a new config.
+func (factory *configFactory) New() Config {
+	return factory.newConfigFunc()
+}
+
+// Creates a new config factory.
+func NewConfigFactory(name Name, f NewConfigFunc) ConfigFactory {
+	return &configFactory{name: name, newConfigFunc: f}
+}

pkg/factory/config_test.go

@@ -0,0 +1,29 @@
+package factory
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type c1 struct{}
+
+func (c1) Validate() error {
+	return nil
+}
+
+func TestNewConfigFactory(t *testing.T) {
+	cf := NewConfigFactory(MustNewName("c1"), func() Config {
+		return c1{}
+	})
+	assert.Equal(t, MustNewName("c1"), cf.Name())
+	assert.IsType(t, c1{}, cf.New())
+}
+
+func TestNewConfigFactoryWithPointer(t *testing.T) {
+	cfp := NewConfigFactory(MustNewName("c1"), func() Config {
+		return &c1{}
+	})
+	assert.Equal(t, MustNewName("c1"), cfp.Name())
+	assert.IsType(t, &c1{}, cfp.New())
+}

pkg/factory/name.go

@@ -0,0 +1,38 @@
+package factory
+
+import (
+	"fmt"
+	"regexp"
+)
+
+var (
+	// nameRegex is a regex that matches a valid name.
+	// It must start with a alphabet, and can only contain alphabets, numbers, underscores or hyphens.
+	nameRegex = regexp.MustCompile(`^[a-z][a-z0-9_-]{0,30}$`)
+)
+
+type Name struct {
+	name string
+}
+
+func (n Name) String() string {
+	return n.name
+}
+
+// NewName creates a new name.
+func NewName(name string) (Name, error) {
+	if !nameRegex.MatchString(name) {
+		return Name{}, fmt.Errorf("invalid factory name %q", name)
+	}
+	return Name{name: name}, nil
+}
+
+// MustNewName creates a new name.
+// It panics if the name is invalid.
+func MustNewName(name string) Name {
+	n, err := NewName(name)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}

pkg/factory/name_test.go

@@ -0,0 +1,20 @@
+package factory
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestName(t *testing.T) {
+	assert.Equal(t, Name{name: "c1"}, MustNewName("c1"))
+}
+
+func TestNameWithInvalidCharacters(t *testing.T) {
+	_, err := NewName("c1%")
+	assert.Error(t, err)
+
+	assert.Panics(t, func() {
+		MustNewName("c1%")
+	})
+}

pkg/factory/named.go

@@ -0,0 +1,74 @@
+package factory
+
+import "fmt"
+
+// Named is implemented by all types of factories.
+type Named interface {
+	Name() Name
+}
+
+type NamedMap[T Named] struct {
+	factories        map[Name]T
+	factoriesInOrder []T
+}
+
+// NewNamedMap creates a new NamedMap from a list of factories.
+// It returns an error if the factories have duplicate names.
+func NewNamedMap[T Named](factories ...T) (NamedMap[T], error) {
+	fmap := make(map[Name]T)
+	for _, factory := range factories {
+		if _, ok := fmap[factory.Name()]; ok {
+			return NamedMap[T]{}, fmt.Errorf("cannot build factory map, duplicate name %q found", factory.Name())
+		}
+
+		fmap[factory.Name()] = factory
+	}
+
+	return NamedMap[T]{factories: fmap, factoriesInOrder: factories}, nil
+}
+
+// MustNewNamedMap creates a new NamedMap from a list of factories.
+// It panics if the factories have duplicate names.
+func MustNewNamedMap[T Named](factories ...T) NamedMap[T] {
+	nm, err := NewNamedMap(factories...)
+	if err != nil {
+		panic(err)
+	}
+	return nm
+}
+
+// Get returns the factory for the given name by string.
+// It returns an error if the factory is not found or the name is invalid.
+func (n *NamedMap[T]) Get(namestr string) (t T, err error) {
+	name, err := NewName(namestr)
+	if err != nil {
+		return
+	}
+
+	factory, ok := n.factories[name]
+	if !ok {
+		err = fmt.Errorf("factory %q not found or not registered", name)
+		return
+	}
+
+	t = factory
+	return
+}
+
+// Add adds a factory to the NamedMap.
+// It returns an error if the factory already exists.
+func (n *NamedMap[T]) Add(factory T) (err error) {
+	name := factory.Name()
+	if _, ok := n.factories[name]; ok {
+		return fmt.Errorf("factory %q already exists", name)
+	}
+
+	n.factories[name] = factory
+	n.factoriesInOrder = append(n.factoriesInOrder, factory)
+	return nil
+}
+
+// GetInOrder returns the factories in the order they were added.
+func (n *NamedMap[T]) GetInOrder() []T {
+	return n.factoriesInOrder
+}

pkg/factory/named_test.go

@@ -0,0 +1,72 @@
+package factory
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type f1 struct{}
+
+func (*f1) Name() Name {
+	return MustNewName("f1")
+}
+
+type f2 struct{}
+
+func (*f2) Name() Name {
+	return MustNewName("f2")
+}
+
+func TestNewNamedMap(t *testing.T) {
+	nm, err := NewNamedMap[Named](&f1{}, &f2{})
+	assert.NoError(t, err)
+	assert.Equal(t, map[Name]Named{
+		MustNewName("f1"): &f1{},
+		MustNewName("f2"): &f2{},
+	}, nm.factories)
+	assert.Equal(t, []Named{&f1{}, &f2{}}, nm.GetInOrder())
+}
+
+func TestNewNamedMapWithDuplicateNames(t *testing.T) {
+	_, err := NewNamedMap[Named](&f1{}, &f1{})
+	assert.Error(t, err)
+}
+
+func TestMustNewNamedMap(t *testing.T) {
+	nm := MustNewNamedMap[Named](&f1{}, &f2{})
+	assert.Equal(t, map[Name]Named{
+		MustNewName("f1"): &f1{},
+		MustNewName("f2"): &f2{},
+	}, nm.factories)
+	assert.Equal(t, []Named{&f1{}, &f2{}}, nm.GetInOrder())
+}
+
+func TestMustNewNamedMapDuplicateNames(t *testing.T) {
+	assert.Panics(t, func() {
+		MustNewNamedMap[Named](&f1{}, &f1{})
+	})
+}
+
+func TestNamedMapGet(t *testing.T) {
+	nm := MustNewNamedMap[Named](&f1{}, &f2{})
+
+	nf1, err := nm.Get("f1")
+	assert.NoError(t, err)
+	assert.IsType(t, &f1{}, nf1)
+
+	_, err = nm.Get("f3")
+	assert.Error(t, err)
+}
+
+func TestNamedMapAdd(t *testing.T) {
+	nm := MustNewNamedMap[Named](&f1{})
+
+	err := nm.Add(&f2{})
+	assert.NoError(t, err)
+	assert.Equal(t, map[Name]Named{
+		MustNewName("f1"): &f1{},
+		MustNewName("f2"): &f2{},
+	}, nm.factories)
+	assert.Equal(t, []Named{&f1{}, &f2{}}, nm.GetInOrder())
+}

pkg/factory/provider.go

@@ -0,0 +1,48 @@
+package factory
+
+import "context"
+
+type Provider = any
+
+// NewProviderFunc is a function that creates a new Provider.
+type NewProviderFunc[P Provider, C Config] func(context.Context, ProviderSettings, C) (P, error)
+
+type ProviderFactory[P Provider, C Config] interface {
+	Named
+	New(context.Context, ProviderSettings, C) (P, error)
+}
+
+type providerFactory[P Provider, C Config] struct {
+	name            Name
+	newProviderFunc NewProviderFunc[P, C]
+}
+
+func (factory *providerFactory[P, C]) Name() Name {
+	return factory.name
+}
+
+func (factory *providerFactory[P, C]) New(ctx context.Context, settings ProviderSettings, config C) (P, error) {
+	return factory.newProviderFunc(ctx, settings, config)
+}
+
+func NewProviderFactory[P Provider, C Config](name Name, newProviderFunc NewProviderFunc[P, C]) ProviderFactory[P, C] {
+	return &providerFactory[P, C]{
+		name:            name,
+		newProviderFunc: newProviderFunc,
+	}
+}
+
+func NewFromFactory[P Provider, C Config](ctx context.Context, settings ProviderSettings, config C, factories NamedMap[ProviderFactory[P, C]], key string) (p P, err error) {
+	providerFactory, err := factories.Get(key)
+	if err != nil {
+		return
+	}
+
+	provider, err := providerFactory.New(ctx, settings, config)
+	if err != nil {
+		return
+	}
+
+	p = provider
+	return
+}

pkg/factory/provider_test.go

@@ -0,0 +1,41 @@
+package factory
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type p1 struct{}
+
+type pc1 struct{}
+
+func (pc1) Validate() error {
+	return nil
+}
+
+func TestNewProviderFactory(t *testing.T) {
+	pf := NewProviderFactory(MustNewName("p1"), func(ctx context.Context, settings ProviderSettings, config pc1) (p1, error) {
+		return p1{}, nil
+	})
+	assert.Equal(t, MustNewName("p1"), pf.Name())
+	p, err := pf.New(context.Background(), ProviderSettings{}, pc1{})
+	assert.NoError(t, err)
+	assert.IsType(t, p1{}, p)
+}
+
+func TestNewProviderFactoryFromFactory(t *testing.T) {
+	pf := NewProviderFactory(MustNewName("p1"), func(ctx context.Context, settings ProviderSettings, config pc1) (p1, error) {
+		return p1{}, nil
+	})
+
+	m := MustNewNamedMap(pf)
+	assert.Equal(t, MustNewName("p1"), pf.Name())
+	p, err := NewFromFactory(context.Background(), ProviderSettings{}, pc1{}, m, "p1")
+	assert.NoError(t, err)
+	assert.IsType(t, p1{}, p)
+
+	_, err = NewFromFactory(context.Background(), ProviderSettings{}, pc1{}, m, "p2")
+	assert.Error(t, err)
+}

pkg/factory/service.go

@@ -0,0 +1,10 @@
+package factory
+
+import "context"
+
+type Service interface {
+	// Starts a service. The service should return an error if it cannot be started.
+	Start(context.Context) error
+	// Stops a service.
+	Stop(context.Context) error
+}