chore: refactored sl and added an hooks system

modified: cmd/dev-server/main.go, cmd/server/main.go

    Aggiornati per utilizzare il nuovo sistema degli hooks, ora nei "main" vanno
    solo chiamate "ProvideValue", "Provide" e "ProvideHook" ed una finale
    di "Invoke" o "Use". Mentre nei vari servizi vanno solo chiamate "Use"
    o "UseHook"

modified: libs/sl/sl.go

    Rinominati "InjectValue" e "InjectLazy" a "Provide" e "ProvideFunc", altro
    refactor di varie cose ed aggiunto il concetto degli hook per poter
    iniettare anche più di un servizio dentro un altro in un preciso ordine.

modified: server/config/config.go

    Lieve refactor ed aggiunta la variabile "NPM_COMMAND" configurabile per la
    fase di development.

modified: server/listautenti/listautenti.go

    Ora questo è un vero e proprio servizio "state-less", fornisce solo una
    funzione che monta tutte le route necessarie a questo servizio. Più avanti
    dipenderà da LDAP quindi forse sarà leggermente più complicato.

modified: server/listautenti/listautenti_test.go

    Aggiornato questo test, ora usa il nuovo sistema e funge di nuovo.

deleted: server/routes/routes.go

    Il sistema degli hook è stato introdotto anche per semplificare questa cosa
    che ora infatti non serve più.

modified: server/server.go

    Ora il server non chiama più "InjectValue" con i sotto-router ma espone solo
    un hook che passa i sotto router come parametri, in questo modo è più
    facile aggiungere e togliere servizi direttamente alla radice quando viene
    configurata tutta l'applicazione.

libs/sl/sl.go

@@ -1,20 +1,20 @@
 // The [sl] package has two main concepts, the [ServiceLocator] itself is the
 // main object that one should pass around through the application. A
 // [ServiceLocator] has a list of slots that can be filled with
-// [InjectLazy] and [InjectValue] and retrieved with [Use]. Slots should
+// [ProvideFunc] and [Provide] and retrieved with [Use]. Slots should
 // be unique by type and they can only be created with the [NewSlot] function.
 //
 // The usual way to use this module is to make slots for Go interfaces and
-// then pass implementations using the [InjectValue] and
-// [InjectLazy] functions.
+// then pass implementations using the [Provide] and
+// [ProvideFunc] functions.
 //
 // Services can be of various types:
 //   - a service with no dependencies can be directly injected inside a
-//     ServiceLocator using [InjectValue].
+//     ServiceLocator using [Provide].
 //   - a service with dependencies on other service should use
-//     [InjectLazy]. This lets the service to initialize itself when needed
+//     [ProvideFunc]. This lets the service configure itself when needed
 //     and makes the developer not think about correctly ordering the
-//     initialization of its dependencies
+//     recursive configuration of its dependencies.
 //   - a service can also be private, in this case the slot for a service
 //     should be a private field in the service package. This kind of
 //     services should also provide a way to inject them into a
@@ -40,8 +40,16 @@ import (
 var Logger *log.Logger = log.New(os.Stderr, "[service locator] ", log.Lmsgprefix)
 
 // slot is just a "typed" unique "symbol".
+//
+// This must be defined like so and not for example "struct{ typeName string }"
+// because we might want to have more slots for the same type.
 type slot[T any] *struct{}
 
+type Hook[T any] func(*ServiceLocator, T) error
+
+// hook is just a typed unique symbol
+type hook[T any] *struct{}
+
 // NewSlot is the only way to create instances of the slot type. Each instance
 // is unique.
 //
@@ -51,85 +59,110 @@ func NewSlot[T any]() slot[T] {
 	return slot[T](new(struct{}))
 }
 
-// slotEntry represents a service that can lazily initialized
-// (using "createFunc"). Once initialized the instance is kept in the "value"
+// NewHook is the only way to create instances of the hook type. Each instance
+// is unique.
+//
+// This lets you have a service dispatch an hook
+func NewHook[T any]() hook[T] {
+	return hook[T](new(struct{}))
+}
+
+// slotEntry represents a service that can lazily configured
+// (using "configureFunc"). Once configured the instance is kept in the "value"
 // field and "created" will always be "true". The field "typeName" just for
 // debugging purposes.
 type slotEntry struct {
+	// typeName is just used for debugging purposes
 	typeName string
 
-	createFunc func(*ServiceLocator) (any, error)
-	created    bool
+	// configureFunc is used by lazily provided slot values to tell how to
+	// configure them self when required
+	configureFunc func(*ServiceLocator) (any, error)
 
+	// configured tells if this slot is already configured
+	configured bool
+
+	// value for this slot
 	value any
 }
 
-func (s *slotEntry) checkInitialized(l *ServiceLocator) error {
-	if !s.created {
-		v, err := s.createFunc(l)
+// checkConfigured tries to call configure on this slot entry if not already configured
+func (s *slotEntry) checkConfigured(l *ServiceLocator) error {
+	if !s.configured {
+		v, err := s.configureFunc(l)
 		if err != nil {
 			return err
 		}
 
-		Logger.Printf(`[slot: %s] initialized value of type %T`, s.typeName, v)
+		Logger.Printf(`[slot: %s] configured service of type %T`, s.typeName, v)
 
-		s.created = true
+		s.configured = true
 		s.value = v
 	}
 
 	return nil
 }
 
+type hookEntry struct {
+	// typeName is just used for debugging purposes
+	typeName string
+
+	// listeners is a list of functions to call when this hook is called
+	listeners []func(*ServiceLocator, any) error
+}
+
 // ServiceLocator is the main context passed around to retrive service
 // instances, the interface uses generics so to inject and retrive service
-// instances you should use the functions [InjectValue], [InjectLazy] and
-// [Use].
+// instances you should use the functions [Provide], [ProvideFunc] and [Use].
+// This is essentially a dictionary indexed by slots that are them self just
+// typed unique symbols
 type ServiceLocator struct {
 	providers map[any]*slotEntry
+	hooks     map[any]*hookEntry
 }
 
 // New creates a new [ServiceLocator] context to pass around in the application.
 func New() *ServiceLocator {
 	return &ServiceLocator{
 		providers: map[any]*slotEntry{},
+		hooks:     map[any]*hookEntry{},
 	}
 }
 
-// InjectValue will inject a concrete instance inside the ServiceLocator "l"
-// for the given "slotKey". This should be used for injecting "static"
-// services, for instances whose construction depend on other services you
-// should use the [InjectLazy] function.
+// Provide will inject a concrete instance inside the ServiceLocator "l" for
+// the given "slotKey". This should be used for injecting "static" services, for
+// instances whose construction depend on other services you should use the
+// [ProvideFunc] function.
 //
 // This is generic over "T" to check that instances for the given slot type
 // check as "T" can also be an interface.
-func InjectValue[T any](l *ServiceLocator, slotKey slot[T], value T) T {
-	Logger.Printf(`[slot: %s] injected value of type %T`, getTypeName[T](), value)
+func Provide[T any](l *ServiceLocator, slotKey slot[T], value T) T {
+	typeName := getTypeName[T]()
+
+	Logger.Printf(`[slot: %s] provided value of type %T`, typeName, value)
 
 	l.providers[slotKey] = &slotEntry{
-		getTypeName[T](),
-		nil,
-		true,
-		value,
+		typeName:   typeName,
+		configured: true,
+		value:      value,
 	}
 	return value
 }
 
-// InjectLazy will inject an instance inside the given ServiceLocator
+// ProvideFunc will inject an instance inside the given ServiceLocator
 // and "slotKey" that is created only when requested with a call to the
 // [Use] function.
 //
 // This is generic over "T" to check that instances for the given slot type
 // check as "T" can also be an interface.
-func InjectLazy[T any](l *ServiceLocator, slotKey slot[T], createFunc func(*ServiceLocator) (T, error)) {
-	Logger.Printf(`[slot: %s] injected lazy`, getTypeName[T]())
+func ProvideFunc[T any](l *ServiceLocator, slotKey slot[T], createFunc func(*ServiceLocator) (T, error)) {
+	typeName := getTypeName[T]()
+	Logger.Printf(`[slot: %s] inject lazy provider`, typeName)
 
 	l.providers[slotKey] = &slotEntry{
-		createFunc: func(l *ServiceLocator) (any, error) {
-			return createFunc(l)
-		},
-		created:  false,
-		value:    nil,
-		typeName: getTypeName[T](),
+		typeName:      typeName,
+		configureFunc: func(l *ServiceLocator) (any, error) { return createFunc(l) },
+		configured:    false,
 	}
 }
 
@@ -137,7 +170,7 @@ func InjectLazy[T any](l *ServiceLocator, slotKey slot[T], createFunc func(*Serv
 // the provided ServiceLocator instance.
 //
 // If the ServiceLocator does not have a value for the slot key, or if the
-// value wasn't correctly initialized (in the case of a lazy slot), an error
+// value wasn't correctly configured (in the case of a lazy slot), an error
 // is returned.
 func Use[T any](l *ServiceLocator, slotKey slot[T]) (T, error) {
 	var zero T
@@ -147,7 +180,7 @@ func Use[T any](l *ServiceLocator, slotKey slot[T]) (T, error) {
 		return zero, fmt.Errorf(`no injected value for type %s`, getTypeName[T]())
 	}
 
-	err := slot.checkInitialized(l)
+	err := slot.checkConfigured(l)
 	if err != nil {
 		return zero, err
 	}
@@ -158,24 +191,84 @@ func Use[T any](l *ServiceLocator, slotKey slot[T]) (T, error) {
 	return v, nil
 }
 
-func Invoke[T any](l *ServiceLocator, slotKey slot[T]) error {
+func MustUse[T any](l *ServiceLocator, slotKey slot[T]) T {
+	v, err := Use(l, slotKey)
+	if err != nil {
+		log.Fatal(err)
+	}
 
+	return v
+}
+
+func Invoke[T any](l *ServiceLocator, slotKey slot[T]) error {
 	slot, ok := l.providers[slotKey]
 	if !ok {
 		return fmt.Errorf(`no injected value for type %s`, getTypeName[T]())
 	}
 
-	err := slot.checkInitialized(l)
+	err := slot.checkConfigured(l)
 	if err != nil {
 		return err
 	}
 
 	v := slot.value.(T)
 
-	Logger.Printf(`[slot: %s] using slot with value of type %T`, getTypeName[T](), v)
+	Logger.Printf(`[slot: %s] invoked slot with value of type %T`, getTypeName[T](), v)
 	return nil
 }
 
+func MustInvoke[T any](l *ServiceLocator, slotKey slot[T]) {
+	if err := Invoke(l, slotKey); err != nil {
+		log.Fatal(err)
+	}
+}
+
+func ProvideHook[T any](l *ServiceLocator, hookKey hook[T], listeners ...Hook[T]) {
+	typeName := getTypeName[T]()
+	Logger.Printf(`[hook: %s] injecting hooks`, typeName)
+
+	// cast type safe listeners to internal untyped version to put inside the hook map
+	anyListeners := make([]func(*ServiceLocator, any) error, len(listeners))
+	for i, l := range listeners {
+		ll := l
+		anyListeners[i] = func(l *ServiceLocator, a any) error {
+			t, ok := a.(T)
+			if !ok {
+				panic(`illegal state`)
+			}
+
+			return ll(l, t)
+		}
+	}
+
+	l.hooks[hookKey] = &hookEntry{
+		typeName:  typeName,
+		listeners: anyListeners,
+	}
+}
+
+func UseHook[T any](l *ServiceLocator, hookKey hook[T], value T) error {
+	hookEntry, ok := l.hooks[hookKey]
+	if !ok {
+		return fmt.Errorf(`no injected hooks for hook of type %s`, hookEntry.typeName)
+	}
+
+	Logger.Printf(`[hook: %s] calling hook with value of type %T`, hookEntry.typeName, value)
+	for _, hookFunc := range hookEntry.listeners {
+		if err := hookFunc(l, value); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func MustUseHook[T any](l *ServiceLocator, hookKey hook[T], value T) {
+	if err := UseHook(l, hookKey, value); err != nil {
+		log.Fatal(err)
+	}
+}
+
 // getTypeName is a trick to get the name of a type (even if it is an
 // interface type)
 func getTypeName[T any]() string {