Skip to content

Controllers

David Ciulla edited this page Nov 7, 2026 · 1 revision

Controllers

Rather than defining all request-handling logic in route closures, you may organise your code into controller modules. Controllers live in app/Http/Controllers/ and follow Elixir's standard module conventions.

Writing Controllers

A controller is a plain Elixir module. Each public function receives a Laravex.Http.Request struct and must return either a Laravex.Http.Response struct or a binary (which is wrapped in an HTML response automatically).

defmodule App.Http.Controllers.PostController do
  use App.Http.Controllers.Controller  # imports Laravex.Support.Helpers

  alias Laravex.View
  alias Laravex.Http.Response

  def index(_request) do
    posts = App.Models.Post.all()
    View.make("posts.index", %{posts: posts})
  end

  def show(request) do
    post = request.params["post"]  # already a struct if model binding is active
    View.make("posts.show", %{post: post})
  end

  def store(request) do
    # validated/0 returns the validated params after FormRequest resolution
    attrs = request.params
    post  = App.Models.Post.create(attrs)
    Response.redirect(route("posts.show", %{"id" => post.id}))
  end

  def update(request) do
    post  = request.params["post"]
    attrs = Map.take(request.params, ["title", "body"])
    App.Models.Post.update(post, attrs)
    Response.redirect(route("posts.show", %{"id" => post.id}))
  end

  def destroy(request) do
    post = request.params["post"]
    App.Models.Post.delete(post)
    Response.redirect(route("posts.index"))
  end
end

Base Controller

The generated app/Http/Controllers/controller.ex provides a use App.Http.Controllers.Controller macro that imports all helpers from Laravex.Support.Helpers into your controller module:

defmodule App.Http.Controllers.Controller do
  defmacro __using__(_opts) do
    quote do
      import Laravex.Support.Helpers
    end
  end
end

This gives every controller access to view/2, redirect/1, route/2, abort/2, back/1, old/2, flash/2, validated/1, and many more helpers without explicit aliasing.

Registering Controller Routes

Pass a {Module, :function} tuple as the route handler:

alias Laravex.Routing.Router

Router.get("/posts",          {App.Http.Controllers.PostController, :index})
Router.post("/posts",         {App.Http.Controllers.PostController, :store})
Router.get("/posts/{id}",     {App.Http.Controllers.PostController, :show})
Router.put("/posts/{id}",     {App.Http.Controllers.PostController, :update})
Router.delete("/posts/{id}",  {App.Http.Controllers.PostController, :destroy})

Or register all seven resource routes at once:

Router.resource("posts", App.Http.Controllers.PostController)

See Routing for the full resource route table.

Form Requests

Attach a Validation FormRequest module to a route via the form_request: option. The router resolves the FormRequest before invoking the handler; the handler receives the validated request or the pipeline short-circuits with a redirect (web) or 422 JSON response (API):

Router.post("/posts", {PostController, :store},
  form_request: App.Http.Requests.StorePostRequest)

Inside the controller, call validated/0 or access request.validated to retrieve only the validated parameters:

def store(request) do
  attrs = request.validated
  ...
end

Returning Responses

Controllers may return any of the standard response helpers:

# HTML view
View.make("posts.index", %{posts: posts})

# JSON
Response.json(%{id: 1, title: "Hello"})

# Redirect
Response.redirect("/posts")
to_route("posts.index")       # redirect by route name

# File download
Response.download(csv_data, "export.csv", content_type: "text/csv")

# 404 / abort
abort(404, "Post not found")
abort(403)

See Responses for the full API.

Clone this wiki locally