Buffalo — API Surface#

// Handler is the fundamental request processing unit.
type Handler func(Context) error

// MiddlewareFunc wraps a Handler; classic onion pattern.
type MiddlewareFunc func(Handler) Handler

// PreWare is a pre-Buffalo-middleware stdlib interceptor (runs before mux routing).
type PreWare func(http.Handler) http.Handler

type Context interface {
    context.Context
    Response() http.ResponseWriter
    Request() *http.Request
    Session() *Session
    Cookies() *Cookies
    Params() ParamValues
    Param(string) string
    Set(string, any)
    LogField(string, any)
    LogFields(map[string]any)
    Logger() Logger
    Bind(any) error
    Render(int, render.Renderer) error
    Error(int, error) error
    Redirect(int, string, ...any) error
    Data() map[string]any
    Flash() *Flash
    File(string) (binding.File, error)
}

// WrapHandler converts an http.Handler to a buffalo.Handler
func WrapHandler(h http.Handler) Handler

// WrapHandlerFunc converts an http.HandlerFunc to a buffalo.Handler
func WrapHandlerFunc(h http.HandlerFunc) Handler

type Resource interface {
    List(Context) error
    Show(Context) error
    Create(Context) error
    Update(Context) error
    Destroy(Context) error
}
// Optional extensions auto-detected at registration:
//   New(Context) error      → GET /resources/new
//   Edit(Context) error     → GET /resources/{id}/edit
// Optional middleware attachment:
type Middler interface {
    Use() []MiddlewareFunc
}
// Default stub implementation:
type BaseResource struct{} // returns 404 for all methods

func New(opts Options) *Engine

type Renderer interface {
    ContentType() string
    Render(io.Writer, Data) error
}
type RendererFunc func(io.Writer, Data) error

// TemplateEngine signature allows registering custom rendering backends
// keyed by file extension in Engine.Options.TemplateEngines map.
type TemplateEngine func(input string, data map[string]any, helpers map[string]any) (string, error)

type Server interface {
    Start(context.Context, http.Handler) error
}
// Constructors:
func NewSimple() *Simple                        // plain HTTP
func NewTLS(cert, key string) *TLS              // HTTPS with cert files
func NewListener(l net.Listener) *Listener      // pre-created listener
// Wrap functions for customising an existing *http.Server before passing to Buffalo:
func WrapSimple(s *http.Server) *Simple
func WrapTLS(s *http.Server, cert, key string) *TLS
func WrapListener(s *http.Server, l net.Listener) *Listener

type Worker interface {
    Register(string, Handler) error
    Start(context.Context) error
    Stop() error
    Perform(Job) error
    PerformAt(Job, time.Time) error
    PerformIn(Job, time.Duration) error
}
type Handler func(Args) error
type Job  struct { Handler string; Args Args; Queue string }
type Args map[string]any
// Default implementation:
type Simple struct{} // in-process goroutine-based queue

// Register a content-type binder
func Register(contentType string, fn Binder)
// Bind a request body to a value
func Exec(req *http.Request, value any) error
// Extend time parsing
func RegisterTimeFormats(layouts ...string)
// Register custom type decoder
func RegisterCustomDecoder(fn CustomTypeDecoder, types []any, fields []any)
// Custom RequestBinder with non-global binders
func NewRequestBinder(binders ...ContenTypeBinder) *RequestBinder

func NewMessage() Message
func NewFromData(data render.Data) Message
func New(c buffalo.Context) Message   // populates from request context

// SMTP sender
func NewSMTPSender(host, port, user, password string) (SMTPSender, error)

// Build a plugin binary:
a := plugcmds.NewAvailable()
a.Add("generate", &cobra.Command{...})   // mount under `buffalo generate`
a.Add("root", &cobra.Command{...})       // mount on `buffalo` root
a.Listen(func(e events.Event) error {...}) // listen to all lifecycle events
a.ListenFor("^app:", fn)                  // regex-filtered event listener
a.Mount(rootCmd)                           // wire into cobra