Controllers

Class-Based Controllers

Recommended for most applications. They provide structure, inheritance, and powerful hooks like before_action.

class PostsController < ApplicationController
  static {
    this.layout = "layouts/posts";
  }

  def index
    @title = "All Posts"
    @posts = Post.all
  end

  def show
    @post = Post.find(params["id"])    # raises 404 if not found
  end
end

Lifecycle Hooks

Execute code before or after actions. Perfect for authentication or data loading.

class PostsController < ApplicationController
  static {
    # Set layout for all actions
    this.layout = "layouts/posts";

    # Run before ALL actions
    this.before_action = fn(req) {
      print("Processing: " + req.path);
      req
    }

    # Run before SPECIFIC actions only
    this.before_action(:show, :edit) = fn(req) {
      @post = Post.find(params["id"])    # raises 404 if not found
      req
    }

    # Run after SPECIFIC actions
    this.after_action(:create, :update) = fn(req, response) {
      # Log activity after create/update
      print("Action completed");
      response
    }
  }

  # ... actions ...
end

Controller Inheritance

Controllers support multi-level inheritance. Create a base controller to share logic across multiple controllers. Hooks like before_action, after_action, and layout are automatically inherited by child controllers.

class BaseController < Controller
  static {
    this.layout = "application";

    this.before_action = fn(req) {
      user_id = req.session["user_id"];
      if user_id != null {
        req["current_user"] = User.find(user_id);
      }
      req
    }
  }

  # Shared helper available to all child controllers
  def _current_user
    this.req["current_user"]
  end
end

# Inherits layout, before_action, and _current_user from BaseController
class PostsController < BaseController
  static {
    # Add controller-specific hook (runs after parent's before_action)
    this.before_action(:show, :edit) = fn(req) {
      @post = Post.find(params["id"])    # raises 404 if not found
      req
    }
  }

  def index
    @posts = Post.all
  end

  def show
    # @post is set by before_action — template renders posts/show
  end
end

# Even deeper inheritance works
class AdminController < BaseController
  static {
    this.layout = "admin";  # Override parent layout

    this.before_action = fn(req) {
      return redirect("/login") if req["current_user"] == null;
      req
    }
  }
end

Nested Controller Directories

Group related controllers into subdirectories under app/controllers/. The directory path becomes part of the controller key, the route base path, and the class name.

app/controllers/
├── home_controller.sl                # HomeController            → /
├── users_controller.sl               # UsersController           → /users
└── admin/
  ├── merchants_controller.sl       # AdminMerchantsController  → /admin/merchants
  └── user_profiles_controller.sl   # AdminUserProfilesController → /admin/user_profiles

Both _ and / act as word separators in the class name, so admin/user_profiles_controller.sl becomes AdminUserProfilesController — there is no :: namespacing.

Reference nested controllers from config/routes.sl using the same controller#action syntax with a /-separated key:

get("/admin/merchants", "admin/merchants#index")
get("/admin/merchants/:id", "admin/merchants#show")

# Or with resources()
resources("/admin/merchants", "admin/merchants")

Function-Based Controllers

Great for simple APIs or microservices where you don't need the full power of classes.

# GET /health
def health
  {
    "status": 200,
    "headers": {"Content-Type": "application/json"},
    "body": "{\"status\":\"ok\"}"
  }
end

The Request Object

Access all HTTP request details through the req parameter.

Cookies

set_cookie("session_id", "abc123");
set_cookie("theme", "dark");

Response Types

render("home/index", { "title": "Welcome" })

render_json({ "users": users })
render_json({ "error": "Not found" }, 404)

class User < Model
  def as_json
    return { "id": this._key, "email": this.email, "name": this.name }
  end
end

# controller — render_json auto-dispatches through the user method:
render_json(user)
# equivalent to: render_json(user.as_json())

render_text("pong")
render_text("Not allowed", 403)

redirect("/login")
redirect("/posts/" + post["id"])

redirect_external("https://github.com/login/oauth/authorize")

redirect(:back)

halt(404, "Page Not Found")
halt(403, "Forbidden")

def show
  post = Post.find(req["params"]["id"])
  respond_to(req, fn(format) {
    format.html(fn()  render("posts/show", { "post": post }))
    format.json(fn()  render_json(post))
    format.csv(fn()   render_csv_for(post))
    format.pdf(fn()   render_pdf_for(post))
    format.excel(fn() render_xlsx_for(post))
    format.htmx(fn()  render("posts/_show_partial", { "post": post }, { "layout": false }))
    format.xhr(fn()   render_json({ "id": post["id"] }))
    format.any(fn()   render("posts/show", { "post": post }))   # optional catch-all
  })
end

respond_to(req, {
  "html": fn() render("posts/show", { "post": post }),
  "json": fn() render_json(post)
})

Request-Context Helpers in Views

These helpers read the current request directly — no need to plumb current_path or current_method through the data hash. They're available in every template (views, layouts, partials).

<nav>
  <a href="/users" class="<%= current_path?("/users") ? "active" : "" %>">Users</a>
  <a href="/posts" class="<%= current_path?("/posts") ? "active" : "" %>">Posts</a>
</nav>

<p>You are viewing <%= current_path() %> (<%= current_method() %>).</p>

For prefix matches (e.g. any path under /users), compose with current_path().starts_with("/users").

Best Practices

• Use class-based controllers for better organization and reuse.
• Create a base ApplicationController to share logic like auth across all controllers.
• Use before_action to load resources and DRY up your code.
• Prefix private helper methods with _ to prevent them from becoming routes.

Next Steps