CHASM: include library name in fully qualified component/task type name

Author: alexshtin

chasm/library.go

@@ -28,7 +28,7 @@ package chasm
 
 type (
 	Library interface {
-		Name() string
+		Namer
 		Components() []*RegistrableComponent
 		Tasks() []*RegistrableTask
 		// Service()
@@ -37,6 +37,10 @@ type (
 	}
 
 	UnimplementedLibrary struct{}
+
+	Namer interface {
+		Name() string
+	}
 )
 
 func (UnimplementedLibrary) Components() []*RegistrableComponent {
@@ -48,3 +52,7 @@ func (UnimplementedLibrary) Tasks() []*RegistrableTask {
 }
 
 func (UnimplementedLibrary) mustEmbedUnimplementedLibrary() {}
+
+func fullyQualifiedName(libName, name string) string {
+	return libName + "." + name
+}

chasm/registrable_component.go

@@ -31,6 +31,7 @@ import (
 type (
 	RegistrableComponent struct {
 		componentType string
+		library       Namer
 		goType        reflect.Type
 
 		ephemeral     bool
@@ -43,10 +44,12 @@ type (
 
 func NewRegistrableComponent[C Component](
 	componentType string,
+	lib Namer,
 	opts ...RegistrableComponentOption,
 ) *RegistrableComponent {
 	rc := &RegistrableComponent{
 		componentType: componentType,
+		library:       lib,
 		goType:        reflect.TypeFor[C](),
 		shardingFn:    defaultShardingFn,
 	}
@@ -77,6 +80,9 @@ func WithShardingFn(
 	}
 }
 
+// Type returns the fully qualified name of the component, which is a combination of
+// the library name and the component type. This is used to uniquely identify
+// the component in the registry.
 func (rc RegistrableComponent) Type() string {
-	return rc.componentType
+	return fullyQualifiedName(rc.library.Name(), rc.componentType)
 }

chasm/registrable_task.go

@@ -31,6 +31,7 @@ import (
 type (
 	RegistrableTask struct {
 		taskType        string
+		library         Namer
 		goType          reflect.Type
 		componentGoType reflect.Type // It is not clear how this one is used.
 		handler         any
@@ -42,11 +43,13 @@ type (
 // NOTE: C is not Component but any.
 func NewRegistrableTask[C any, T any](
 	taskType string,
+	lib Namer,
 	handler TaskHandler[C, T],
 	opts ...RegistrableTaskOption,
 ) *RegistrableTask {
 	rt := &RegistrableTask{
 		taskType:        taskType,
+		library:         lib,
 		goType:          reflect.TypeFor[T](),
 		componentGoType: reflect.TypeFor[C](),
 		handler:         handler,
@@ -57,6 +60,9 @@ func NewRegistrableTask[C any, T any](
 	return rt
 }
 
-func (rt RegistrableTask) Type() string {
-	return rt.taskType
+// Type returns the fully qualified name of the task, which is a combination of
+// the library name and the task type. This is used to uniquely identify
+// the task in the registry.
+func (rc RegistrableTask) Type() string {
+	return fullyQualifiedName(rc.library.Name(), rc.taskType)
 }

chasm/registry.go

@@ -92,18 +92,14 @@ func (r *Registry) taskFor(taskInstance any) (*RegistrableTask, bool) {
 	return rt, ok
 }
 
-func (r *Registry) fqn(libName, name string) string {
-	return libName + "." + name
-}
-
 func (r *Registry) registerComponent(
 	libName string,
 	rc *RegistrableComponent,
 ) error {
 	if err := r.validateName(rc.componentType); err != nil {
 		return err
 	}
-	fqn := r.fqn(libName, rc.componentType)
+	fqn := fullyQualifiedName(libName, rc.componentType)
 	if _, ok := r.componentByType[fqn]; ok {
 		return fmt.Errorf("component %s is already registered", fqn)
 	}
@@ -127,7 +123,7 @@ func (r *Registry) registerTask(
 	if err := r.validateName(rt.taskType); err != nil {
 		return err
 	}
-	fqn := r.fqn(libName, rt.taskType)
+	fqn := fullyQualifiedName(libName, rt.taskType)
 	if _, ok := r.taskByType[fqn]; ok {
 		return fmt.Errorf("task %s is already registered", fqn)
 	}

chasm/registry_test.go

@@ -46,7 +46,7 @@ func TestRegistry_RegisterComponents_Success(t *testing.T) {
 	lib := chasm.NewMockLibrary(ctrl)
 	lib.EXPECT().Name().Return("TestLibrary").AnyTimes()
 	lib.EXPECT().Components().Return([]*chasm.RegistrableComponent{
-		chasm.NewRegistrableComponent[*chasm.MockComponent]("Component1"),
+		chasm.NewRegistrableComponent[*chasm.MockComponent]("Component1", lib),
 	})
 
 	lib.EXPECT().Tasks().Return(nil)
@@ -56,7 +56,7 @@ func TestRegistry_RegisterComponents_Success(t *testing.T) {
 
 	rc1, ok := r.Component("TestLibrary.Component1")
 	require.True(t, ok)
-	require.Equal(t, "Component1", rc1.Type())
+	require.Equal(t, "TestLibrary.Component1", rc1.Type())
 
 	missingRC, ok := r.Component("TestLibrary.Component2")
 	require.False(t, ok)
@@ -65,7 +65,7 @@ func TestRegistry_RegisterComponents_Success(t *testing.T) {
 	cInstance1 := chasm.NewMockComponent(ctrl)
 	rc2, ok := r.ComponentFor(cInstance1)
 	require.True(t, ok)
-	require.Equal(t, "Component1", rc2.Type())
+	require.Equal(t, "TestLibrary.Component1", rc2.Type())
 
 	cInstance2 := "invalid component instance"
 	rc3, ok := r.ComponentFor(cInstance2)
@@ -81,16 +81,16 @@ func TestRegistry_RegisterTasks_Success(t *testing.T) {
 	lib.EXPECT().Components().Return(nil)
 
 	lib.EXPECT().Tasks().Return([]*chasm.RegistrableTask{
-		chasm.NewRegistrableTask[*chasm.MockComponent, testTask1]("Task1", chasm.NewMockTaskHandler[*chasm.MockComponent, testTask1](ctrl)),
-		chasm.NewRegistrableTask[testTaskComponentInterface, testTask2]("Task2", chasm.NewMockTaskHandler[testTaskComponentInterface, testTask2](ctrl)),
+		chasm.NewRegistrableTask[*chasm.MockComponent, testTask1]("Task1", lib, chasm.NewMockTaskHandler[*chasm.MockComponent, testTask1](ctrl)),
+		chasm.NewRegistrableTask[testTaskComponentInterface, testTask2]("Task2", lib, chasm.NewMockTaskHandler[testTaskComponentInterface, testTask2](ctrl)),
 	})
 
 	err := r.Register(lib)
 	require.NoError(t, err)
 
 	rt1, ok := r.Task("TestLibrary.Task1")
 	require.True(t, ok)
-	require.Equal(t, "Task1", rt1.Type())
+	require.Equal(t, "TestLibrary.Task1", rt1.Type())
 
 	missingRT, ok := r.Task("TestLibrary.TaskMissing")
 	require.False(t, ok)
@@ -99,7 +99,7 @@ func TestRegistry_RegisterTasks_Success(t *testing.T) {
 	tInstance1 := testTask2{}
 	rt2, ok := r.TaskFor(tInstance1)
 	require.True(t, ok)
-	require.Equal(t, "Task2", rt2.Type())
+	require.Equal(t, "TestLibrary.Task2", rt2.Type())
 
 	tInstance2 := "invalid task instance"
 	rt3, ok := r.TaskFor(tInstance2)
@@ -135,7 +135,7 @@ func TestRegistry_RegisterComponents_Error(t *testing.T) {
 
 	t.Run("component name must not be empty", func(t *testing.T) {
 		lib.EXPECT().Components().Return([]*chasm.RegistrableComponent{
-			chasm.NewRegistrableComponent[*chasm.MockComponent](""),
+			chasm.NewRegistrableComponent[*chasm.MockComponent]("", lib),
 		})
 		r := chasm.NewRegistry()
 		err := r.Register(lib)
@@ -145,7 +145,7 @@ func TestRegistry_RegisterComponents_Error(t *testing.T) {
 
 	t.Run("component name must follow rules", func(t *testing.T) {
 		lib.EXPECT().Components().Return([]*chasm.RegistrableComponent{
-			chasm.NewRegistrableComponent[*chasm.MockComponent]("bad.component.name"),
+			chasm.NewRegistrableComponent[*chasm.MockComponent]("bad.component.name", lib),
 		})
 		r := chasm.NewRegistry()
 		err := r.Register(lib)
@@ -155,8 +155,8 @@ func TestRegistry_RegisterComponents_Error(t *testing.T) {
 
 	t.Run("component is already registered by name", func(t *testing.T) {
 		lib.EXPECT().Components().Return([]*chasm.RegistrableComponent{
-			chasm.NewRegistrableComponent[*chasm.MockComponent]("Component1"),
-			chasm.NewRegistrableComponent[*chasm.MockComponent]("Component1"),
+			chasm.NewRegistrableComponent[*chasm.MockComponent]("Component1", lib),
+			chasm.NewRegistrableComponent[*chasm.MockComponent]("Component1", lib),
 		})
 		r := chasm.NewRegistry()
 		err := r.Register(lib)
@@ -166,8 +166,8 @@ func TestRegistry_RegisterComponents_Error(t *testing.T) {
 
 	t.Run("component is already registered by type", func(t *testing.T) {
 		lib.EXPECT().Components().Return([]*chasm.RegistrableComponent{
-			chasm.NewRegistrableComponent[*chasm.MockComponent]("Component1"),
-			chasm.NewRegistrableComponent[*chasm.MockComponent]("Component2"),
+			chasm.NewRegistrableComponent[*chasm.MockComponent]("Component1", lib),
+			chasm.NewRegistrableComponent[*chasm.MockComponent]("Component2", lib),
 		})
 		r := chasm.NewRegistry()
 
@@ -178,7 +178,7 @@ func TestRegistry_RegisterComponents_Error(t *testing.T) {
 
 	t.Run("component must be a struct", func(t *testing.T) {
 		lib.EXPECT().Components().Return([]*chasm.RegistrableComponent{
-			chasm.NewRegistrableComponent[chasm.Component]("Component1"),
+			chasm.NewRegistrableComponent[chasm.Component]("Component1", lib),
 		})
 		r := chasm.NewRegistry()
 
@@ -198,7 +198,7 @@ func TestRegistry_RegisterTasks_Error(t *testing.T) {
 	t.Run("task name must not be empty", func(t *testing.T) {
 		r := chasm.NewRegistry()
 		lib.EXPECT().Tasks().Return([]*chasm.RegistrableTask{
-			chasm.NewRegistrableTask[*chasm.MockComponent, testTask1]("", chasm.NewMockTaskHandler[*chasm.MockComponent, testTask1](ctrl)),
+			chasm.NewRegistrableTask[*chasm.MockComponent, testTask1]("", lib, chasm.NewMockTaskHandler[*chasm.MockComponent, testTask1](ctrl)),
 		})
 		err := r.Register(lib)
 		require.Error(t, err)
@@ -207,7 +207,7 @@ func TestRegistry_RegisterTasks_Error(t *testing.T) {
 
 	t.Run("task name must follow rules", func(t *testing.T) {
 		lib.EXPECT().Tasks().Return([]*chasm.RegistrableTask{
-			chasm.NewRegistrableTask[*chasm.MockComponent, testTask1]("bad.task.name", chasm.NewMockTaskHandler[*chasm.MockComponent, testTask1](ctrl)),
+			chasm.NewRegistrableTask[*chasm.MockComponent, testTask1]("bad.task.name", lib, chasm.NewMockTaskHandler[*chasm.MockComponent, testTask1](ctrl)),
 		})
 		r := chasm.NewRegistry()
 		err := r.Register(lib)
@@ -217,8 +217,8 @@ func TestRegistry_RegisterTasks_Error(t *testing.T) {
 
 	t.Run("task is already registered by name", func(t *testing.T) {
 		lib.EXPECT().Tasks().Return([]*chasm.RegistrableTask{
-			chasm.NewRegistrableTask[*chasm.MockComponent, testTask1]("Task1", chasm.NewMockTaskHandler[*chasm.MockComponent, testTask1](ctrl)),
-			chasm.NewRegistrableTask[*chasm.MockComponent, testTask1]("Task1", chasm.NewMockTaskHandler[*chasm.MockComponent, testTask1](ctrl)),
+			chasm.NewRegistrableTask[*chasm.MockComponent, testTask1]("Task1", lib, chasm.NewMockTaskHandler[*chasm.MockComponent, testTask1](ctrl)),
+			chasm.NewRegistrableTask[*chasm.MockComponent, testTask1]("Task1", lib, chasm.NewMockTaskHandler[*chasm.MockComponent, testTask1](ctrl)),
 		})
 		r := chasm.NewRegistry()
 		err := r.Register(lib)
@@ -228,8 +228,8 @@ func TestRegistry_RegisterTasks_Error(t *testing.T) {
 
 	t.Run("task is already registered by type", func(t *testing.T) {
 		lib.EXPECT().Tasks().Return([]*chasm.RegistrableTask{
-			chasm.NewRegistrableTask[*chasm.MockComponent, testTask1]("Task1", chasm.NewMockTaskHandler[*chasm.MockComponent, testTask1](ctrl)),
-			chasm.NewRegistrableTask[*chasm.MockComponent, testTask1]("Task2", chasm.NewMockTaskHandler[*chasm.MockComponent, testTask1](ctrl)),
+			chasm.NewRegistrableTask[*chasm.MockComponent, testTask1]("Task1", lib, chasm.NewMockTaskHandler[*chasm.MockComponent, testTask1](ctrl)),
+			chasm.NewRegistrableTask[*chasm.MockComponent, testTask1]("Task2", lib, chasm.NewMockTaskHandler[*chasm.MockComponent, testTask1](ctrl)),
 		})
 		r := chasm.NewRegistry()
 		err := r.Register(lib)
@@ -240,7 +240,7 @@ func TestRegistry_RegisterTasks_Error(t *testing.T) {
 	t.Run("task component struct must implement Component", func(t *testing.T) {
 		lib.EXPECT().Tasks().Return([]*chasm.RegistrableTask{
 			// MockComponent has only pointer receivers and therefore does not implement Component interface.
-			chasm.NewRegistrableTask[chasm.MockComponent, testTask1]("Task1", chasm.NewMockTaskHandler[chasm.MockComponent, testTask1](ctrl)),
+			chasm.NewRegistrableTask[chasm.MockComponent, testTask1]("Task1", lib, chasm.NewMockTaskHandler[chasm.MockComponent, testTask1](ctrl)),
 		})
 		r := chasm.NewRegistry()
 		err := r.Register(lib)
@@ -250,7 +250,7 @@ func TestRegistry_RegisterTasks_Error(t *testing.T) {
 
 	t.Run("task must be struct", func(t *testing.T) {
 		lib.EXPECT().Tasks().Return([]*chasm.RegistrableTask{
-			chasm.NewRegistrableTask[*chasm.MockComponent, string]("Task1", chasm.NewMockTaskHandler[*chasm.MockComponent, string](ctrl)),
+			chasm.NewRegistrableTask[*chasm.MockComponent, string]("Task1", lib, chasm.NewMockTaskHandler[*chasm.MockComponent, string](ctrl)),
 		})
 		r := chasm.NewRegistry()
 		err := r.Register(lib)

chasm/test_library_test.go

@@ -38,9 +38,9 @@ func (l *TestLibrary) Name() string {
 
 func (l *TestLibrary) Components() []*RegistrableComponent {
 	return []*RegistrableComponent{
-		NewRegistrableComponent[*TestComponent]("test_component"),
-		NewRegistrableComponent[*TestSubComponent1]("test_sub_component_1"),
-		NewRegistrableComponent[*TestSubComponent11]("test_sub_component_11"),
-		NewRegistrableComponent[*TestSubComponent2]("test_sub_component_2"),
+		NewRegistrableComponent[*TestComponent]("test_component", l),
+		NewRegistrableComponent[*TestSubComponent1]("test_sub_component_1", l),
+		NewRegistrableComponent[*TestSubComponent11]("test_sub_component_11", l),
+		NewRegistrableComponent[*TestSubComponent2]("test_sub_component_2", l),
 	}
 }