app
API
app
packageAPI reference for the app
package.
Imports
(9)
STD
context
STD
fmt
STD
log/slog
INT
github.com/mirkobrombin/go-foundation/pkg/di
INT
github.com/mirkobrombin/go-foundation/pkg/dispatcher
INT
github.com/mirkobrombin/go-foundation/pkg/hosting
INT
github.com/mirkobrombin/go-foundation/pkg/scheduler
INT
github.com/mirkobrombin/go-foundation/pkg/srv
STD
testing
I
interface
Handler
Handler is the interface for declarative struct-tagged endpoints.
pkg/app/app.go:16-18
type Handler interface
Methods
S
struct
App
App orchestrates DI, HTTP, dispatching, and scheduling into a single entrypoint.
pkg/app/app.go:21-29
type App struct
Methods
Log
Method
Log sets the application logger.
Parameters
logger
*slog.Logger
Returns
*App
func (*App) Log(logger *slog.Logger) *App
{
a.logger = logger
return a
}
Provide
Method
Provide registers a named dependency for injection into handler structs.
Parameters
name
string
instance
any
Returns
*App
func (*App) Provide(name string, instance any) *App
{
a.builder.Provide(name, instance)
return a
}
RegisterHTTP
Method
RegisterHTTP registers a struct-tagged HTTP handler.
func (*App) RegisterHTTP(h Handler) *App
{
a.handlerReg = append(a.handlerReg, h)
return a
}
RegisterAction
Method
RegisterAction registers a named action handler for dispatch.
Parameters
name
string
handler
func(ctx context.Context, payload ...any) (any, error)
Returns
*App
func (*App) RegisterAction(name string, handler func(ctx context.Context, payload ...any) (any, error)) *App
{
a.dispatch.Register(name, handler)
return a
}
Dispatch
Method
Dispatch calls a named action handler.
Parameters
Returns
any
error
func (*App) Dispatch(ctx context.Context, name string, payload ...any) (any, error)
{
return a.dispatch.Dispatch(ctx, name, payload...)
}
Schedule
Method
Schedule registers a cron job.
Parameters
name
string
cronExpr
string
handler
func(ctx context.Context) error
Returns
*App
func (*App) Schedule(name, cronExpr string, handler func(ctx context.Context) error) *App
{
a.sched.Register(scheduler.Job{Name: name, Cron: cronExpr, Handler: handler})
return a
}
Use
Method
Use adds middleware to the HTTP server.
Parameters
Returns
*App
func (*App) Use(mw srv.Middleware) *App
{
a.server.Use(mw)
return a
}
Configure
Method
Configure allows direct customization of the underlying srv.Server.
Parameters
fn
func(*srv.Server)
Returns
*App
func (*App) Configure(fn func(*srv.Server)) *App
{
fn(a.server)
return a
}
Build
Method
Build constructs the DI container and registers all handlers.
Returns
error
func (*App) Build() (*di.Container, error)
{
container, err := a.builder.Build()
if err != nil {
return nil, err
}
a.container = container
for _, h := range a.handlerReg {
a.server.RegisterHandler(h, container)
}
return container, nil
}
Listen
Method
Listen starts the HTTP server and scheduler, then blocks until shutdown.
Parameters
addr
string
Returns
error
func (*App) Listen(addr string) error
{
if a.container == nil {
if _, err := a.Build(); err != nil {
return fmt.Errorf("app: build failed: %w", err)
}
}
if addr == "" {
addr = ":8080"
}
h := hosting.NewBuilder().
WithAddr(addr).
AddHostedService(&schedulerHost{sched: a.sched}).
Build()
h.Server = a.server
return h.Run(context.Background())
}Fields
| Name | Type | Description |
|---|---|---|
| container | *di.Container | |
| server | *srv.Server | |
| dispatch | *dispatcher.Dispatcher | |
| sched | *scheduler.Scheduler | |
| builder | *di.Builder | |
| logger | *slog.Logger | |
| handlerReg | []Handler |
F
function
New
New creates a new App with default components.
Returns
*App
pkg/app/app.go:32-40
func New() *App
{
return &App{
builder: di.NewBuilder(),
server: srv.New(),
dispatch: dispatcher.New(),
sched: scheduler.New(),
logger: slog.Default(),
}
}
S
struct
schedulerHost
pkg/app/app.go:126-128
type schedulerHost struct
Methods
Start
Method
Parameters
ctx
context.Context
Returns
error
func (*schedulerHost) Start(ctx context.Context) error
{
go s.sched.Start(ctx)
return nil
}
Stop
Method
Parameters
ctx
context.Context
Returns
error
func (*schedulerHost) Stop(ctx context.Context) error
{
return s.sched.Stop(ctx)
}Fields
| Name | Type | Description |
|---|---|---|
| sched | *scheduler.Scheduler |
S
struct
greetEndpoint
pkg/app/app_test.go:8-11
type greetEndpoint struct
Methods
Handle
Method
Parameters
Returns
any
error
func (*greetEndpoint) Handle(_ context.Context) (any, error)
{
return greetResponse{Message: "hello " + e.Name}, nil
}Fields
| Name | Type | Description |
|---|---|---|
| Meta | struct{} | method:"GET" path:"/greet" |
| Name | string | query:"name" default:"world" |
S
struct
greetResponse
pkg/app/app_test.go:13-15
type greetResponse struct
Fields
| Name | Type | Description |
|---|---|---|
| Message | string | json:"message" |
F
function
TestApp_New
Parameters
t
pkg/app/app_test.go:21-26
func TestApp_New(t *testing.T)
{
a := New()
if a == nil {
t.Fatal("New() returned nil")
}
}
F
function
TestApp_Provide
Parameters
t
pkg/app/app_test.go:28-31
func TestApp_Provide(t *testing.T)
{
a := New()
a.Provide("db", "fake-connection")
}
F
function
TestApp_RegisterHTTP
Parameters
t
pkg/app/app_test.go:33-36
func TestApp_RegisterHTTP(t *testing.T)
{
a := New()
a.RegisterHTTP(&greetEndpoint{})
}
F
function
TestApp_RegisterAction
Parameters
t
pkg/app/app_test.go:38-43
func TestApp_RegisterAction(t *testing.T)
{
a := New()
a.RegisterAction("test", func(ctx context.Context, payload ...any) (any, error) {
return "ok", nil
})
}
F
function
TestApp_Dispatch
Parameters
t
pkg/app/app_test.go:45-57
func TestApp_Dispatch(t *testing.T)
{
a := New()
a.RegisterAction("ping", func(ctx context.Context, payload ...any) (any, error) {
return "pong", nil
})
result, err := a.Dispatch(context.Background(), "ping")
if err != nil {
t.Fatalf("Dispatch: %v", err)
}
if result != "pong" {
t.Errorf("result = %v, want pong", result)
}
}
F
function
TestApp_Schedule
Parameters
t
pkg/app/app_test.go:59-64
func TestApp_Schedule(t *testing.T)
{
a := New()
a.Schedule("cleanup", "0 0 * * *", func(ctx context.Context) error {
return nil
})
}