The Go framework that ships batteries included

// cmd/app/main.go
func main() {
    app.Configure().
        WithProviders(bootstrap.LoadProviders()).
        WithRoutes(bootstrap.LoadRoutes()).
        WithMiddlewares(bootstrap.LoadMiddlewares()).
    Run()
}

// bootstrap/providers.go
func LoadProviders() []app.Provider {
    return []app.Provider{
        &session.Provider{},
        &gormconnector.Provider{UseGPA: true},
        &inertia.Provider{},
        &queue.Provider{},
        &auth.Provider{},
    }
}

// internal/routes/web.go
func WebRoutes(a app.App) {
    r := a.Router()

    r.Get("/articles", handlers.ArticleIndex)
    r.Get("/articles/{id}", handlers.ArticleShow)

    admin := r.Group("/admin")
    admin.UseBefore(middleware.AdminAuth)
    admin.Get("/articles/new", handlers.ArticleCreate)
    admin.Post("/articles", handlers.ArticleStore)
}

// bootstrap/middleware.go
func LoadMiddlewares() []app.Handler {
    return []app.Handler{
        middleware.VerifyCSRF(&middleware.CSRFOpts{
            ExcludePatterns: []string{"/api/.*"},
        }),
    }
}

// internal/inputs/article_input.go
type CreateArticleInput struct {
    Title string `json:"title"`
    Body  string `json:"body"`
}

func (i *CreateArticleInput) Validate() error {
    v := app.NewValidator()
    v.Field("title", i.Title).Required().Max(255)
    v.Field("body", i.Body).Required()
    return v.Validate()
}

// internal/handlers/article_handler.go
func ArticleStore(c app.Context) error {
    input, err := c.Input(&CreateArticleInput{}).(*CreateArticleInput)
    if err != nil {
        return c.UnprocessableEntity(err)
    }
    article := &models.Article{
        Title: input.Title,
        Body:  input.Body,
    }
    Article().Create(c.RequestContext(), article)
    return inertia.Redirect(c, "/articles")
}

// internal/migrations/20250706000001_create_articles_table.go
func init() {
    migration.GetMigrator().AddMigration(&migration.Migration{
        Version: "20250706000001",
        Up:      mig_up, Down: mig_down,
    })
}

func mig_up(tx *sql.Tx) error {
    schema := migration.Create("articles", func(t *migration.Table) {
        t.BigIncrements("id")
        t.String("title").NotNull()
        t.Text("body")
        t.String("status").Default("'draft'")
        t.ForeignID("author_id").Constrained()
        t.Timestamps()
    }).Build()
    _, err := tx.Exec(schema)
    return err
}

// internal/repos/article_repo.go
type ArticleRepository struct {
    gpa.MigratableRepository[models.Article]
}

func Article() *ArticleRepository {
    return &ArticleRepository{
        gpagorm.GetRepository[models.Article](),
    }
}

// internal/handlers/article_handler.go
func ArticleIndex(c app.Context) error {
    articles, _ := Article().FindAll(c.RequestContext(),
        gpa.Where("status", gpa.OpEqual, "published"),
        gpa.OrderBy("created_at", gpa.OrderDesc),
        gpa.Preload("Author"),
    )
    return c.JSON(app.M{"articles": articles})
}

type SendEmail struct {
    Email string `json:"email"`
    UserID int   `json:"user_id"`
}

func (j *SendEmail) Handle(ctx context.Context) error {
    fmt.Printf("Sending email to %s\n", j.Email)
    return nil
}

func init() {
    queue.RegisterJob("*jobs.SendEmail", func() queue.Job {
        return &SendEmail{}
    })
}

// Dispatched from any handler
queue.Dispatch(ctx, &SendEmail{
    Email: "user@test.com", UserID: 42,
})

// Workers claim and process jobs
// $ lemmego run tasker:work --queue=default --workers=3

// internal/handlers/article_handler.go
func ArticleIndex(c app.Context) error {
    articles, _ := Article().FindAll(c.RequestContext(),
        gpa.Where("status", gpa.OpEqual, "published"),
        gpa.Preload("Author"),
    )
    return inertia.Respond(c, "Articles/Index", map[string]any{
        "articles": articles,
    })
}

// resources/js/Pages/Articles/Index.tsx
export default function Index({ articles }: PageProps) {
    return (
        <div>
            {articles.map(article => (
                <ArticleCard key={article.id} article={article} />
            ))}
        </div>
    );
}

// plugins/cms/provider.go
type CMSProvider struct{}

func (p *CMSProvider) Provide(a app.App) error {
    a.AddService(NewCMS(a.Config()))
    a.Router().Get("/sitemap.xml", p.Sitemap)
    return nil
}

func (p *CMSProvider) Sitemap(c app.Context) error {
    articles, _ := Article().FindAll(c.RequestContext(),
        gpa.Where("status", gpa.OpEqual, "published"),
    )
    return c.XML(app.M{"sitemap": buildSitemap(articles)})
}

// bootstrap/providers.go
func LoadProviders() []app.Provider {
    return []app.Provider{
        // ...framework providers...
        &plugins.CMSProvider{},
    }
}