Add module for server.

context.go

@@ -82,7 +82,7 @@ type runtimeContext struct {
 	request        *http.Request
 	responseWriter http.ResponseWriter
 	pathParams     httprouter.Params
-	modules        module.Modules
+	repo           *module.Repo
 
 	logger    *slog.Logger
 	reqCodec  Codec
@@ -103,8 +103,11 @@ func getRuntimeContext(ctx Context) *runtimeContext {
 }
 
 func (c *runtimeContext) Value(key any) any {
-	if ret := c.modules.Value(key); ret != nil {
-		return ret
+	moduleKey, ok := key.(module.ModuleKey)
+	if ok {
+		if ret := c.repo.Value(moduleKey); ret != nil {
+			return ret
+		}
 	}
 
 	switch key {

examples/module_test.go

@@ -21,11 +21,11 @@ func NewDB(ctx context.Context) (*DB, error) {
 	}, nil
 }
 
-func (d *DB) CheckHealthy(ctx context.Context) error {
+func (d *DB) CheckHealth(ctx context.Context) error {
 	return nil
 }
 
-var ModuleDB = module.NewModule(NewDB)
+var ModuleDB = module.New(NewDB)
 
 type Cache struct {
 	Cache string
@@ -38,11 +38,11 @@ func NewCache(ctx context.Context) (*Cache, error) {
 	}, nil
 }
 
-func (c *Cache) CheckHealthy(ctx context.Context) error {
+func (c *Cache) CheckHealth(ctx context.Context) error {
 	return nil
 }
 
-var ModuleCache = module.NewModule(NewCache)
+var ModuleCache = module.New(NewCache)
 
 type MessageQueue struct {
 	Queue string
@@ -54,11 +54,11 @@ func NewMQ(ctx context.Context) (*MessageQueue, error) {
 	}, nil
 }
 
-func (r *MessageQueue) CheckHealthy(ctx context.Context) error {
+func (r *MessageQueue) CheckHealth(ctx context.Context) error {
 	return nil
 }
 
-var ModuleMQ = module.NewModule(NewMQ)
+var ModuleMQ = module.New(NewMQ)
 
 func Handler(ctx espresso.Context) error {
 	if err := ctx.Endpoint(http.MethodGet, "/").End(); err != nil {
@@ -76,7 +76,9 @@ func Handler(ctx espresso.Context) error {
 
 func LaunchModule() (addr string, cancel func()) {
 	server, _ := espresso.New()
-	if err := server.AddModule(ModuleCache, ModuleMQ, ModuleDB); err != nil {
+
+	ctx := context.Background()
+	if err := server.AddModule(ctx, ModuleCache, ModuleMQ, ModuleDB); err != nil {
 		panic(err)
 	}
 

module/context.go

@@ -0,0 +1,59 @@
+package module
+
+import "context"
+
+type errBuildError struct {
+	name contextKey
+	err  error
+}
+
+type buildContext struct {
+	context.Context
+	mod      ModuleKey
+	dependOn map[contextKey]struct{}
+	repo     *Repo
+}
+
+func newBuildContext(ctx context.Context, repo *Repo) *buildContext {
+	return &buildContext{
+		Context: ctx,
+		repo:    repo,
+	}
+}
+
+func (ctx *buildContext) Child(mod ModuleKey) *buildContext {
+	return &buildContext{
+		Context:  ctx.Context,
+		mod:      mod,
+		dependOn: make(map[contextKey]struct{}),
+		repo:     ctx.repo,
+	}
+}
+
+func (ctx *buildContext) Value(name any) any {
+	key, ok := name.(ModuleKey)
+	if !ok {
+		return ctx.Context.Value(name)
+	}
+
+	ctx.dependOn[key.contextKey()] = struct{}{}
+
+	if ret := ctx.repo.Value(key); ret != nil {
+		return ret
+	}
+
+	if err := key.build(ctx); err != nil {
+		panic(errBuildError{name: key.contextKey(), err: err})
+	}
+
+	return ctx.repo.Value(key)
+}
+
+func (ctx *buildContext) addInstance(instance Instance) {
+	deps := make([]contextKey, 0, len(ctx.dependOn))
+	for key := range ctx.dependOn {
+		deps = append(deps, key)
+	}
+
+	ctx.repo.addInstance(ctx.mod, deps, instance)
+}

module/module.go

@@ -2,76 +2,81 @@ package module
 
 import (
 	"context"
-	"errors"
 	"fmt"
+	"reflect"
 )
 
-var ErrModuleDependError = errors.New("depend error")
-var ErrModuleNotFound = errors.New("not found module")
-var errBuildError = errors.New("build error")
-
-type nameKey string
+type Instance interface {
+	CheckHealth(context.Context) error
+}
 
-type Module interface {
-	Name() nameKey
-	DependOn() []nameKey
-	CheckHealthy(context.Context) error
+type BuildFunc[T Instance] func(context.Context) (T, error)
 
+type ModuleKey interface {
+	contextKey() contextKey
 	build(*buildContext) error
 }
+type contextKey string
 
-func CheckHealthy(ctx context.Context, names []nameKey) error {
-	errs := make(map[nameKey]error)
+type Module[T Instance] struct {
+	ModuleKey
+	name    contextKey
+	buildFn BuildFunc[T]
+}
 
-	checkModuleHealthy(ctx, names, errs)
+func New[T Instance](buildFunc BuildFunc[T]) Module[T] {
+	var t T
+	return Module[T]{
+		name:    contextKey(reflect.TypeOf(t).String()),
+		buildFn: buildFunc,
+	}
+}
 
-	if len(errs) != 0 {
-		ret := make([]error, 0, len(errs))
-		for name, err := range errs {
-			ret = append(ret, fmt.Errorf("module %s: %w", name, err))
-		}
-		return errors.Join(ret...)
+func (m Module[T]) Value(ctx context.Context) (ret T) {
+	v := ctx.Value(m)
+	if v == nil {
+		return
 	}
 
-	return nil
+	return v.(T)
 }
 
-func checkModuleHealthy(ctx context.Context, names []nameKey, errs map[nameKey]error) {
-	for _, name := range names {
-		if _, ok := errs[name]; ok {
-			continue
-		}
+func (m Module[T]) String() string {
+	return fmt.Sprintf("Module[%s]", m.name)
+}
 
-		v := ctx.Value(name)
-		if v == nil {
-			errs[name] = ErrModuleNotFound
-			continue
-		}
-		module, ok := v.(Module)
-		if !ok {
-			errs[name] = ErrModuleNotFound
-			continue
-		}
+func (m Module[T]) contextKey() contextKey {
+	return m.name
+}
 
-		depHealthy := true
-		if deps := module.DependOn(); len(deps) != 0 {
-			checkModuleHealthy(ctx, deps, errs)
+func (m Module[T]) build(ctx *buildContext) (err error) {
+	t := ctx.Value(m.name)
+	if t != nil {
+		return nil
+	}
 
-			for _, depname := range deps {
-				if errs[depname] != nil {
-					depHealthy = false
-					break
-				}
-			}
-		}
+	bctx := ctx.Child(m)
 
-		if !depHealthy {
-			errs[name] = ErrModuleDependError
-			continue
+	defer func() {
+		p := recover()
+		if p == nil {
+			return
 		}
 
-		if err := module.CheckHealthy(ctx); err != nil {
-			errs[name] = err
+		e, ok := p.(errBuildError)
+		if !ok {
+			panic(p)
 		}
+
+		err = fmt.Errorf("Module[%s] build error: %w", e.name, e.err)
+	}()
+
+	instance, err := m.buildFn(bctx)
+	if err != nil {
+		return fmt.Errorf("Module[%s] build error: %w", m.name, err)
 	}
+
+	bctx.addInstance(instance)
+
+	return nil
 }