Genie.jl Documentation

Genie is a full-stack web framework for the Julia programming language designed for high developer productivity and run-time performance. It follows a 'no-magic' approach that stays true to Julia's idioms:

• Controllers: Implemented as plain Julia modules.
• Models: Leverage Julia's type system and multiple dispatch.
• App Management: Genie apps are standard Julia projects, using Julia's Pkg for dependency management.
• Development Workflow: Automatically supports code loading and reloading via Revise.

The framework is designed to scale from simple scripts or REPL-based prototypes to complex, structured MVC (Model-View-Controller) applications. For database persistence, Genie provides an ORM called SearchLight.

The Genie Framework is a suite of tools for web development in Julia:

• Genie.jl: The core server backend (routing, templating, authentication).
• Stipple.jl: For building reactive UIs using a low-code Julia API.
• Genie Builder: A VSCode plugin for visual drag-and-drop UI building.
• SearchLight.jl: A complete ORM for database integration (Postgres, MySQL, SQLite, etc.).

You can enforce types on route parameters by appending ::Type to the parameter name in the route definition (e.g., :x::Int).

Note: By default, Genie extracts parameters as SubString{String}. To use type constraints, you must ensure Julia knows how to convert a string to that type. For Int, you may need to extend Base.convert:

Base.convert(::Type{Int}, s::AbstractString) = parse(Int, s)

Once configured, Genie will automatically attempt to convert the URL segment to the specified type before passing it to the handler.

# 1. Setup conversion for Int
Base.convert(::Type{Int}, s::AbstractString) = parse(Int, s)

# 2. Define route with type constraints
route("/sum/:x::Int/:y::Int") do
    params(:x) + params(:y)
end

For larger projects, Genie uses a Model-View-Controller (MVC) architecture organized around "resources".

• Resource: Represents a business entity (e.g., user, product, books).
• Location: Resources are stored in app/resources/<resource_name>/.
• Components: A resource typically includes a Controller (e.g., BooksController.jl), a Model (e.g., Books.jl), a Model Validator (e.g., BooksValidator.jl), and a views/ folder.

Note: The app/ folder is automatically created the first time you add a resource using Genie's generators.

Genie uses an abstraction called channels to manage client-server communication over WebSockets. Conceptually, channels are the WebSocket equivalent of routes. Instead of HTTP requests, the client and server exchange messages over these channels. Genie's Router handles incoming WebSocket messages by extracting the payload and invoking a designated handler (either a function or a controller method), mirroring the standard MVC workflow used in HTTP routing.

using Genie.Router

# Define a channel with a block handler
channel("/foo/bar") do
  # process request
end

# Define a channel with a controller method handler
channel("/baz/bax", YourController.your_handler)

All definitions (variables, constants, functions, modules, etc.) added within initializer files are loaded directly into your application's module.

If your application is named MyGenieApp, you can access these definitions via MyGenieApp.variable_name. Because the application name can vary, you can also access these definitions using the Main.UserApp constant, which points to your application's module.

In a standard Genie workflow:

1. A Route maps a URL to a specific method in a Controller.
2. The Controller method (the route handler) processes logic and calls a View to render the response.
3. The View (HTML, Markdown, or JSON) generates the final content sent to the client.

To expose a controller method, add a route in routes.jl:

using MyGenieApp.BooksController
route("/endpoint", BooksController.method_name)

Because definitions in config/secrets.jl are loaded into your app's module, they are available under your application's specific namespace.

If your application module is named MyGenieApp, you can access a secret defined as API_KEY via MyGenieApp.API_KEY.

Alternatively, you can use the Main.UserApp constant to access these definitions regardless of your specific application name.