Gin, with the boring parts done.

package main

import (
	"log"

	"github.com/klass-lk/ginboot"
	"github.com/klass-lk/ginboot/example/internal/controller"
)

func main() {
	// Loads ginboot.yml / application.yml and .env automatically
	server := ginboot.New()
	cfg := server.Config()

	server.SetBasePath(cfg.Ginboot.Server.BasePath)
	server.RegisterController("/posts", controller.NewPostController(svc))

	// Runs as HTTP locally, as an API Gateway proxy on AWS Lambda
	if err := server.Start(cfg.Ginboot.Server.Port); err != nil {
		log.Fatal(err)
	}
}

package controller

import "github.com/klass-lk/ginboot"

func (c *PostController) Register(group *ginboot.ControllerGroup) {
	group.GET("/:id", c.GetPost)

	protected := group.Group("")
	protected.POST("", c.CreatePost)
}

// Handlers return (DTO, error) — Ginboot handles binding,
// status codes and JSON serialisation for you.
func (c *PostController) GetPost(ctx *ginboot.Context) (model.Post, error) {
	return c.postService.GetPostById(ctx.Param("id"))
}

func (c *PostController) CreatePost(ctx *ginboot.Context, req model.Post) (model.Post, error) {
	post, err := c.postService.CreatePost(req)
	if err != nil {
		return model.Post{}, ginboot.NewApiError(400, "invalid post")
	}

	// Fire-and-forget call to another service, traced end to end
	_ = ctx.CallServiceAsync("notification-service", "/notifications/send", post)

	return post, nil
}