Getting started

go get github.com/kryovyx/rex

A complete application

package main
import (
	"time"
	"github.com/kryovyx/rex"
	"github.com/kryovyx/rex/logger"
	"github.com/kryovyx/rex/route"
)
type UserService struct{}
func (s *UserService) Greet(name string) string { return "Hello, " + name }
func main() {
	app := rex.New(
		rex.WithConfig(&rex.Config{
			DefaultRouter: rex.RouterConfig{Addr: ":8080"},
			ShutdownTimeout: 30 * time.Second,
		}),
		rex.WithLogLevel(logger.LogLevelDebug),
	)
	// Dependencies
	if err := app.Container().Singleton(func() *UserService {
		return &UserService{}
	}); err != nil {
		panic(err)
	}
	// Routes
	if err := app.RegisterRoute(route.New("GET", "/", func(ctx route.Context) {
		_ = ctx.JSON(200, map[string]string{"message": "Welcome to Rex"})
	})); err != nil {
		panic(err)
	}
	if err := app.RegisterRoute(route.New("GET", "/greet/{name}", func(ctx route.Context) {
		var svc *UserService
		if err := ctx.Resolver().Resolve(&svc); err != nil {
			_ = ctx.JSON(500, map[string]string{"error": "unavailable"})
			return
		}
		_ = ctx.Text(200, svc.Greet(ctx.Param("name")))
	})); err != nil {
		panic(err)
	}
	if err := app.Run(); err != nil {
		panic(err)
	}
}

$ curl localhost:8080/greet/ada
Hello, ada

Check the errors

if err := errors.Join(
	app.RegisterRoute(route.New("GET", "/users", listUsers)),
	app.RegisterRoute(route.New("POST", "/users", createUser)),
	app.RegisterRoute(route.New("GET", "/users/{id}", getUser)),
); err != nil {
	return fmt.Errorf("routes: %w", err)
}

Three ways to configure

// Options to New.
app := rex.New(rex.WithConfig(cfg), rex.WithLogLevel(logger.LogLevelDebug))
// Fluent.
app := rex.New().
	WithOptions(rex.WithConfig(cfg)).
	WithLogger(logger.NewSlogLoggerWithLevel(logger.LogLevelDebug))
// After the fact — still fine, because nothing is built until Run.
app := rex.New()
app.WithOptions(rex.WithConfig(cfg))

Adding an extension

import (
	"github.com/kryovyx/rex"
	health "github.com/kryovyx/rextension-health"
	metric "github.com/kryovyx/rextension-metric"
)
app := rex.New(
	health.WithHealth(nil), // /healthz, /readyz on a dedicated listener
	metric.WithMetrics(nil), // /metrics, plus request instrumentation
)

Running with a context

ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
defer cancel()
if err := app.RunContext(ctx); err != nil {
	log.Fatal(err)
}

Testing an application

func TestGreet(t *testing.T) {
	app := rex.New(rex.WithConfig(&rex.Config{
		DefaultRouter: rex.RouterConfig{Addr: "127.0.0.1:0"}, // any free port
	}))
	if err := app.RegisterRoute(route.New("GET", "/greet/{name}", greet)); err != nil {
		t.Fatal(err)
	}
	errCh := make(chan error, 1)
	go func() { errCh <- app.Run() }()
	t.Cleanup(func() {
		_ = app.Stop()
		if err := <-errCh; err != nil {
			t.Errorf("run: %v", err)
		}
	})
	// app.Routers()["default"].Addr() is the bound address.
}

Next