refactor_with_definitions

definitions/type.DependencyCollection.go

@@ -0,0 +1,16 @@
+package definitions
+
+import (
+	"reflect"
+
+	"github.com/MY-RV/gosc/enums/scopeStatus"
+)
+
+type DependencyCollection interface {
+	GetDependencyFactory(reflect.Type) (Factory, error)
+	GetRegisteredDependencies() []reflect.Type
+	GetScopeStatus() scopeStatus.Enum
+
+	GetDependency(reflect.Type) (any, error)
+	MustGetDependency(reflect.Type) any
+}

definitions/type.DependencyCollectionBuilder.go

@@ -0,0 +1,12 @@
+package definitions
+
+import "github.com/MY-RV/gosc/enums/scope"
+
+type DependencyCollectionBuilder interface {
+	AddDependency(scope.Enum, Factory)
+	AddSingleton(Factory)
+	AddTransient(Factory)
+	AddScoped(Factory)
+
+	Build() DependencyCollection
+}

definitions/type.DependencyRecord.go

@@ -0,0 +1,10 @@
+package definitions
+
+import (
+	"github.com/MY-RV/gosc/enums/scope"
+)
+
+type DependencyRecord interface {
+	GetFactory() Factory
+	GetScope() scope.Enum
+}

definitions/type.Factory.go

@@ -0,0 +1,8 @@
+package definitions
+
+import "reflect"
+
+type Factory interface {
+	GetFactoryType() reflect.Type
+	Create(DependencyCollection) any
+}

definitions/type.TypedFactory.go

@@ -0,0 +1,6 @@
+package definitions
+
+type TypedFactory[T any] interface {
+	Factory
+	TypedCreate(DependencyCollection) T
+}

enums/scope/enum.go

@@ -4,5 +4,6 @@ type Enum int
 
 const (
 	SINGLETON Enum = iota
+	TRANSIENT
 	SCOPED
 )

enums/scope_status/enum.go → enums/scopeStatus/enum.go

@@ -1,4 +1,4 @@
-package scope_status
+package scopeStatus
 
 type Enum int
 

enums/scope_status/enum_test.go → enums/scopeStatus/enum_test.go

@@ -1,4 +1,4 @@
-package scope_status
+package scopeStatus
 
 import "testing"
 

internal/defaults/dependencyCollection/dependencyCollection.GetDependency.go

@@ -0,0 +1,8 @@
+package dependencyCollection
+
+import "reflect"
+
+// GetDependency implements definitions.DependencyCollection.
+func (d *dependencyCollection) GetDependency(reflect.Type) (any, error) {
+	panic("unimplemented")
+}

internal/defaults/dependencyCollection/dependencyCollection.GetDependencyFactory.go

@@ -0,0 +1,12 @@
+package dependencyCollection
+
+import (
+	"reflect"
+
+	"github.com/MY-RV/gosc/definitions"
+)
+
+// GetDependencyFactory implements definitions.DependencyCollection.
+func (d *dependencyCollection) GetDependencyFactory(reflect.Type) (definitions.Factory, error) {
+	panic("unimplemented")
+}

internal/defaults/dependencyCollection/dependencyCollection.GetRegisteredDependencies.go

@@ -0,0 +1,8 @@
+package dependencyCollection
+
+import "reflect"
+
+// GetRegisteredDependencies implements definitions.DependencyCollection.
+func (d *dependencyCollection) GetRegisteredDependencies() []reflect.Type {
+	panic("unimplemented")
+}

internal/defaults/dependencyCollection/dependencyCollection.GetScopeStatus.go

@@ -0,0 +1,8 @@
+package dependencyCollection
+
+import "github.com/MY-RV/gosc/enums/scopeStatus"
+
+// GetScopeStatus implements definitions.DependencyCollection.
+func (d *dependencyCollection) GetScopeStatus() scopeStatus.Enum {
+	return d.scopeStatus
+}

internal/defaults/dependencyCollection/dependencyCollection.MustGetDependency.go

@@ -0,0 +1,8 @@
+package dependencyCollection
+
+import "reflect"
+
+// MustGetDependency implements definitions.DependencyCollection.
+func (d *dependencyCollection) MustGetDependency(reflect.Type) any {
+	panic("unimplemented")
+}

internal/defaults/dependencyCollection/dependencyCollectionBuilder.AddDependency.go

@@ -0,0 +1,14 @@
+package dependencyCollection
+
+import (
+	"github.com/MY-RV/gosc/definitions"
+	"github.com/MY-RV/gosc/enums/scope"
+	"github.com/MY-RV/gosc/internal/defaults/dependencyRecord"
+)
+
+// AddDependency implements definitions.DependencyCollectionBuilder.
+func (d *dependencyCollectionBuilder) AddDependency(scope scope.Enum, factory definitions.Factory) {
+	dependencyRecord := dependencyRecord.Default(factory, scope)
+	registry := d.dependencyCollection.registry
+	registry[factory.GetFactoryType()] = dependencyRecord
+}

internal/defaults/dependencyCollection/dependencyCollectionBuilder.AddScoped.go

@@ -0,0 +1,11 @@
+package dependencyCollection
+
+import (
+	"github.com/MY-RV/gosc/definitions"
+	"github.com/MY-RV/gosc/enums/scope"
+)
+
+// AddScoped implements definitions.DependencyCollectionBuilder.
+func (d *dependencyCollectionBuilder) AddScoped(factory definitions.Factory) {
+	d.AddDependency(scope.SCOPED, factory)
+}

internal/defaults/dependencyCollection/dependencyCollectionBuilder.AddSingleton.go

@@ -0,0 +1,11 @@
+package dependencyCollection
+
+import (
+	"github.com/MY-RV/gosc/definitions"
+	"github.com/MY-RV/gosc/enums/scope"
+)
+
+// AddSingleton implements definitions.DependencyCollectionBuilder.
+func (d *dependencyCollectionBuilder) AddSingleton(factory definitions.Factory) {
+	d.AddDependency(scope.SCOPED, factory)
+}

internal/defaults/dependencyCollection/dependencyCollectionBuilder.AddTransient.go

@@ -0,0 +1,11 @@
+package dependencyCollection
+
+import (
+	"github.com/MY-RV/gosc/definitions"
+	"github.com/MY-RV/gosc/enums/scope"
+)
+
+// AddTransient implements definitions.DependencyCollectionBuilder.
+func (d *dependencyCollectionBuilder) AddTransient(factory definitions.Factory) {
+	d.AddDependency(scope.SCOPED, factory)
+}

internal/defaults/dependencyCollection/dependencyCollectionBuilder.Build.go

@@ -0,0 +1,19 @@
+package dependencyCollection
+
+import (
+	"reflect"
+
+	"github.com/MY-RV/gosc/definitions"
+	"github.com/MY-RV/gosc/enums/scopeStatus"
+	"github.com/MY-RV/gosc/internal/helpers/map_helper"
+)
+
+// Build implements definitions.DependencyCollectionBuilder.
+func (d *dependencyCollectionBuilder) Build() definitions.DependencyCollection {
+	return &dependencyCollection{
+		singletonServices: d.dependencyCollection.singletonServices,
+		scopedServices:    make(map[reflect.Type]any),
+		registry:          map_helper.CopyMap(d.dependencyCollection.registry),
+		scopeStatus:       scopeStatus.ACTIVE,
+	}
+}

internal/defaults/dependencyCollection/pkg.NewBuilder.go

@@ -0,0 +1,19 @@
+package dependencyCollection
+
+import (
+	"reflect"
+
+	"github.com/MY-RV/gosc/definitions"
+	"github.com/MY-RV/gosc/enums/scopeStatus"
+)
+
+func NewBuilder() definitions.DependencyCollectionBuilder {
+	return &dependencyCollectionBuilder{
+		dependencyCollection: dependencyCollection{
+			singletonServices: make(map[reflect.Type]any),
+			scopedServices:    make(map[reflect.Type]any),
+			registry:          make(map[reflect.Type]definitions.DependencyRecord),
+			scopeStatus:       scopeStatus.INACTIVE,
+		},
+	}
+}

internal/defaults/dependencyCollection/type.dependencyCollection.go

@@ -0,0 +1,22 @@
+package dependencyCollection
+
+import (
+	"reflect"
+
+	"github.com/MY-RV/gosc/definitions"
+	"github.com/MY-RV/gosc/enums/scopeStatus"
+)
+
+// Implements github.com/MY-RV/gosc/definitions::DependencyCollection
+type dependencyCollection struct {
+	singletonServices map[reflect.Type]any
+	scopedServices    map[reflect.Type]any
+
+	registry    map[reflect.Type]definitions.DependencyRecord
+	scopeStatus scopeStatus.Enum
+}
+
+// TYPE CHECKING
+func init() {
+	var _ definitions.DependencyCollection = &dependencyCollection{}
+}

internal/defaults/dependencyCollection/type.dependencyCollectionBuilder.go

@@ -0,0 +1,15 @@
+package dependencyCollection
+
+import (
+	"github.com/MY-RV/gosc/definitions"
+)
+
+// Implements github.com/MY-RV/gosc/definitions::DependencyCollectionBuilder
+type dependencyCollectionBuilder struct {
+	dependencyCollection dependencyCollection
+}
+
+// TYPE CHECKING
+func init() {
+	var _ definitions.DependencyCollectionBuilder = &dependencyCollectionBuilder{}
+}

internal/defaults/dependencyRecord/dependencyRecord.GetFactory.go

@@ -0,0 +1,8 @@
+package dependencyRecord
+
+import "github.com/MY-RV/gosc/definitions"
+
+// GetFactory implements definitions.DependencyRecord.
+func (d *dependencyRecord) GetFactory() definitions.Factory {
+	return d.factory
+}

internal/defaults/dependencyRecord/dependencyRecord.GetScope.go

@@ -0,0 +1,8 @@
+package dependencyRecord
+
+import "github.com/MY-RV/gosc/enums/scope"
+
+// GetScope implements definitions.DependencyRecord.
+func (d *dependencyRecord) GetScope() scope.Enum {
+	return d.scope
+}

internal/defaults/dependencyRecord/pkg.Default.go

@@ -0,0 +1,13 @@
+package dependencyRecord
+
+import (
+	"github.com/MY-RV/gosc/definitions"
+	"github.com/MY-RV/gosc/enums/scope"
+)
+
+func Default(factory definitions.Factory, scope scope.Enum) definitions.DependencyRecord {
+	return &dependencyRecord{
+		factory: factory,
+		scope:   scope,
+	}
+}

internal/defaults/dependencyRecord/type.dependencyRecord.go

@@ -0,0 +1,16 @@
+package dependencyRecord
+
+import (
+	"github.com/MY-RV/gosc/definitions"
+	"github.com/MY-RV/gosc/enums/scope"
+)
+
+type dependencyRecord struct {
+	factory definitions.Factory
+	scope   scope.Enum
+}
+
+// TYPE CHECKING
+func init() {
+	var _ definitions.DependencyRecord = &dependencyRecord{}
+}

internal/defaults/factories/pkg.TypedFactory.go

@@ -0,0 +1,8 @@
+package factories
+
+import "github.com/MY-RV/gosc/definitions"
+
+// Implements github.com/MY-RV/gosc/definitions.TypedFactory
+type TypedFactory[T any] struct {
+	factoryFunction func(definitions.DependencyCollection) T
+}

internal/defaults/factories/typedFactory/DependencyTypedFactory.Create.go

@@ -0,0 +1,8 @@
+package typedFactory
+
+import "github.com/MY-RV/gosc/definitions"
+
+// Implements github.com/MY-RV/gosc/definitions::TypedFactory.Create
+func (typedFactory *DependencyTypedFactory[T]) Create(dependencyCollection definitions.DependencyCollection) any {
+	return typedFactory.factoryFunction(dependencyCollection)
+}

internal/defaults/factories/typedFactory/DependencyTypedFactory.GetFactoryType.go

@@ -0,0 +1,8 @@
+package typedFactory
+
+import "reflect"
+
+// Implements github.com/MY-RV/gosc/definitions::TypedFactory.GetFactoryType
+func (typedFactory *DependencyTypedFactory[T]) GetFactoryType() reflect.Type {
+	return typedFactory.factoryType
+}

internal/defaults/factories/typedFactory/DependencyTypedFactory.TypedCreate.go

@@ -0,0 +1,8 @@
+package typedFactory
+
+import "github.com/MY-RV/gosc/definitions"
+
+// Implements github.com/MY-RV/gosc/definitions::TypedFactory.TypedCreate
+func (typedFactory *DependencyTypedFactory[T]) TypedCreate(dependencyCollection definitions.DependencyCollection) T {
+	return typedFactory.factoryFunction(dependencyCollection)
+}

internal/defaults/factories/typedFactory/pkg.NewDependencyTypedFactory.go

@@ -0,0 +1,17 @@
+package typedFactory
+
+import (
+	"reflect"
+
+	"github.com/MY-RV/gosc/definitions"
+)
+
+func NewDependencyTypedFactory[T any](factoryFunction func(definitions.DependencyCollection) T) DependencyTypedFactory[T] {
+	reflectType := reflect.TypeOf(factoryFunction)
+	dependencyType := reflectType.Out(0)
+
+	return DependencyTypedFactory[T]{
+		factoryFunction: factoryFunction,
+		factoryType:     dependencyType,
+	}
+}

internal/defaults/factories/typedFactory/type.DependencyTypedFactory.go

@@ -0,0 +1,13 @@
+package typedFactory
+
+import (
+	"reflect"
+
+	"github.com/MY-RV/gosc/definitions"
+)
+
+// Implements github.com/MY-RV/gosc/definitions::DependencyTypedFactory
+type DependencyTypedFactory[T any] struct {
+	factoryFunction func(definitions.DependencyCollection) T
+	factoryType     reflect.Type
+}

internal/helpers/map_helper/CopyMap.go

@@ -0,0 +1,9 @@
+package map_helper
+
+func CopyMap[K comparable, V any](m map[K]V) map[K]V {
+    result := make(map[K]V, len(m))
+    for k, v := range m {
+        result[k] = v
+    }
+    return result
+}