### Activate Environment and Install Dependencies

Source: https://github.com/levkk/rwf/blob/main/examples/django/README.md

Activates the previously created virtual environment and installs all necessary Python packages listed in the 'requirements.txt' file. This step ensures all project dependencies are met.

```bash
source venv/bin/activate
pip install -r requirements.txt
```

--------------------------------

### Install Rwf CLI

Source: https://github.com/levkk/rwf/blob/main/docs/docs/user-guides/build-your-app/index.md

Installs the Rwf Command Line Interface using Cargo, the Rust package manager. This command is the first step required to start building applications with Rwf.

```shell
cargo install rwf-cli
```

--------------------------------

### Launch Rwf Web Server

Source: https://github.com/levkk/rwf/blob/main/docs/docs/index.md

Shows how to configure and launch the Rwf HTTP server. It includes setting up routes, initializing logging, and running the application.

```rust
use rwf::http::{self, Server};

#[tokio::main]
async fn main() -> Result<(), http::Error> {
    // Configure the logger.
    Logger::init();

    // Define routes.
    let routes = vec![
        route!("/" => index),
    ];

    // Launch the HTTP server.
    Server::new(routes)
        .launch()
        .await
}
```

--------------------------------

### Install Rwf CLI

Source: https://github.com/levkk/rwf/blob/main/docs/docs/models/migrations.md

Installs the Rwf command-line interface tool using Cargo, which is necessary for managing migrations and other project setup tasks.

```shell
cargo install rwf-cli
```

--------------------------------

### Setup Stimulus Application with Custom Controllers (JavaScript)

Source: https://github.com/levkk/rwf/blob/main/rwf-admin/templates/rwf_admin/head.html

This snippet initializes a Stimulus application and registers two custom controllers: 'Requests' and 'Reload'. It imports necessary components from the Stimulus library and the custom controller files, then starts the application. This setup is crucial for enabling Stimulus's declarative behavior in the application.

```javascript
import { Application } from "hotwired/stimulus";

const application = Application.start();

import Requests from "/static/rwf_admin/js/requests_controller.js";
import Reload from "/static/rwf_admin/js/reload_controller.js";

application.register("requests", Requests);
application.register("reload", Reload);
```

--------------------------------

### Create Rust Project with Cargo

Source: https://github.com/levkk/rwf/blob/main/docs/docs/index.md

Initializes a new Rust binary project using Cargo, the Rust package manager. This command sets up the basic project structure required for a web application.

```bash
cargo init --bin rwf-web-app &&
cd rwf-web-app
```

--------------------------------

### Rust: Start WebSocket Server

Source: https://github.com/levkk/rwf/blob/main/docs/docs/controllers/websockets.md

Illustrates how to start an Rwf server with WebSocket support by adding a WebSocket controller to the server routes. This example configures the server to listen for WebSocket connections at the `/websocket` path. Requires `rwf::prelude::*` and `rwf::http::{Server, http}`.

```rust
use rwf::prelude::*;
use rwf::http::{ Server, http };

#[tokio::main]
async fn main() -> Result<(), http::Error> {
    let server = Server::new(vec![
        route!("/websocket" => Echo),
    ])
    .launch()
    .await
}
```

--------------------------------

### Rwf CLI Commands Overview

Source: https://github.com/levkk/rwf/blob/main/docs/docs/models/migrations.md

Displays the available commands and options for the Rwf CLI, providing an entry point to manage migrations, project setup, and get help.

```apidoc
rwf-cli --help

Rust Web Framework CLI

Usage: rwf-cli <COMMAND>

Commands:
  migrate  Manage migrations
  setup    Setup the project for Rwf
  help     Print this message or the help of the given subcommand(s)

Options:
  -h, --help     Print help
  -V, --version  Print version
```

--------------------------------

### Add Rwf Crate to Project

Source: https://github.com/levkk/rwf/blob/main/docs/docs/index.md

Adds the Rwf crate as a dependency to your Rust project's Cargo.toml file. This makes the Rwf framework available for use in your application.

```bash
cargo add rwf
```

--------------------------------

### Run the Application with Cargo

Source: https://github.com/levkk/rwf/blob/main/examples/django/README.md

Executes the application using the Cargo build tool. This command typically starts the Rust backend server which hosts the Django application.

```bash
cargo run
```

--------------------------------

### Run the Application

Source: https://github.com/levkk/rwf/blob/main/examples/turbo/README.md

Command to compile and run the Rust application using the Cargo build tool.

```rust
cargo run
```

--------------------------------

### Define Rwf Controller

Source: https://github.com/levkk/rwf/blob/main/docs/docs/index.md

Demonstrates how to define a simple asynchronous controller function using the `#[controller]` macro in Rwf. It returns an HTML response.

```rust
use rwf::prelude::*;

#[controller]
async fn index() -> Response {
    Response::new().html("<h1>My first Rwf app!</h1>")
}
```

--------------------------------

### Create PostgreSQL Database

Source: https://github.com/levkk/rwf/blob/main/examples/turbo/README.md

Command to create the PostgreSQL database named 'rwf_turbo' required for the application.

```shell
createdb rwf_turbo
```

--------------------------------

### Up Migration Example

Source: https://github.com/levkk/rwf/blob/main/docs/docs/models/migrations.md

An example of an 'up' migration script that creates a 'users' table with an ID, email, and creation timestamp.

```sql
CREATE TABLE users (
    id BIGSERIAL PRIMARY KEY,
    email VARCHAR UNIQUE NOT NULL,
    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
```

--------------------------------

### Explaining Query Plans

Source: https://github.com/levkk/rwf/blob/main/examples/orm/README.md

Demonstrates how to get the query execution plan without actually running the query by using the `.explain()` method. This is helpful for performance analysis and optimization.

```rust
let query_plan = User::all()
    .filter_lte("created_at", OffsetDateTime::now_utc())
    .limit(25)
    .explain(&mut conn)
    .await?;

println!("{}", query_plan);
// Filter: (created_at <= '2024-10-09 10:23:31.561024-07'::timestamp with time zone)
```

--------------------------------

### Install Rwf CLI with Cargo

Source: https://github.com/levkk/rwf/blob/main/rwf-cli/README.md

Installs the Rwf CLI tool globally using the Rust package manager, Cargo. After installation, ensure that `~/.cargo/bin/` is included in your system's PATH environment variable for the CLI to be accessible.

```shell
$ cargo install rwf-cli

```

--------------------------------

### PageController Login Example

Source: https://github.com/levkk/rwf/blob/main/docs/docs/controllers/pages.md

Illustrates using the `PageController` trait for a login page. The `async fn get` method handles rendering the login form, while `async fn post` processes form data, validates user credentials, and redirects the user upon successful login.

```rust
use rwf::prelude::*;

#[derive(Default, macros::PageController)]
struct Login;

impl PageController for Login {
    // Handle GET and show the login form.
    async fn get(&self, request: &Request) -> Result<Response, Error> {
        render!(request, "templates/login.html")
    }

    // Handle POST, receive form data, check information, and
    // redirect the logged in user to a different page.
    async fn post(&self, request: &Request) -> Result<Response, Error> {
        let form = request.form_data();

        let email = form.get_required::<String>("email");
        let password = form.get_required::<String>("password");

        // Check that the user exists

        Ok(Response::new().login(user.id).redirect("/account"))
    }
}
```

--------------------------------

### Install Rwf Admin

Source: https://github.com/levkk/rwf/blob/main/rwf-admin/README.md

Demonstrates how to install the Rwf admin panel into an existing Rust application by adding it to routes and preloading templates at startup. Requires `rwf` and `rwf-admin` crates.

```rust
use rwf::prelude::*;
use rwf::http::{Server, Error};

#[tokio::main]
async fn main() -> Result<(), Error> {
    rwf_admin::install()?;

    let mut routes = vec![];
    // Add your routes...

    routes.extend(rwf_admin::routes());

    Server::new(routes)
        .launch()
        .await
}
```

--------------------------------

### Create Python Virtual Environment

Source: https://github.com/levkk/rwf/blob/main/examples/django/README.md

Creates a new Python virtual environment named 'venv'. This isolates project dependencies from the global Python installation, ensuring a clean and reproducible build environment.

```bash
python3 -m venv venv
```

--------------------------------

### Basic Rwf Application Setup

Source: https://github.com/levkk/rwf/blob/main/rwf/README.md

This Rust code snippet demonstrates how to set up a minimal Rwf web application. It defines a simple controller function that returns an HTML response and configures the server to listen for requests on the root path.

```rust
use rwf::prelude::*;
use rwf::http::Server;

#[controller]
async fn index() -> Response {
    Response::new().html("<h1>Welcome to Rwf!</h1>")
}

#[tokio::main]
async fn main() {
    Server::new(vec![
        route!("/" => index),
    ])
    .launch()
    .await
    .unwrap();
}
```

--------------------------------

### Rwf TOML Configuration Structure

Source: https://github.com/levkk/rwf/blob/main/docs/docs/configuration.md

Illustrates the structure and common settings within the `rwf.toml` configuration file, including sections for general application settings and database connection parameters.

```toml
# Example rwf.toml configuration

[general]
host = "0.0.0.0"
port = 8000
log_queries = false
secret_key = "YOUR_BASE64_SECRET_KEY"
cache_templates = false
csrf_protection = true
max_request_size = "5MB"

[database]
name = "mydatabase"
user = "myuser"
url = "postgresql://user:password@host:port/database_name"
checkout_timeout = 5000
idle_timeout = 3600000
```

--------------------------------

### List Users Output Example

Source: https://github.com/levkk/rwf/blob/main/docs/docs/controllers/REST/model-controller.md

Example JSON output for a request to list users, showing user objects with their properties.

```json
[
  {"id": 1, "email": "admin@example.com", "admin": true},
  {"id": 2, "email": "alice1@example.com", "admin": false}
]
```

--------------------------------

### Serve Static Files in RWF

Source: https://github.com/levkk/rwf/blob/main/docs/docs/controllers/static-files.md

This example demonstrates how to integrate the RWF `StaticFiles` controller into your application's server setup. It configures the server to serve files from the 'static' directory under the '/static' route, automatically handling MIME types based on file extensions. The `StaticFiles` controller is added to the `Server` during initialization.

```rust
use rwf::controller::StaticFiles;
use rwf::http::{Server, self};

#[tokio::main]
async fn main() -> Result<(), http::Error> {
    let server = Server::new(vec![
        StaticFiles::serve("static")?,
    ])
    .launch()
    .await;
    Ok(())
}
```

--------------------------------

### SQL Query Example

Source: https://github.com/levkk/rwf/blob/main/examples/orm/README.md

An example SQL query generated by the ORM for fetching a record by its primary key.

```sql
SELECT * FROM users WHERE id = 15;
```

--------------------------------

### PageController for GET and POST

Source: https://github.com/levkk/rwf/blob/main/examples/quick-start/README.md

Illustrates using the `PageController` trait to handle different HTTP methods (GET, POST) within a single controller. The `get` method handles GET requests, and the `post` method handles POST requests, simplifying form submissions.

```rust
use rwf::controllers::PageController;
use rwf::prelude::*;

#[derive(rwf::macros::PageController)]
struct SignupController;

#[async_trait]
impl PageController for SignupController {
    async fn get(&self, request: &Request) -> Result<Response, Error> {
        Ok(Response::new().html(r#"
            <!DOCTYPE html>
            <html>
              <body>
                <form action="/signup" method="post">
                  <%= csrf_token() %>
                  <label>Email</labelL
                  <input name="email" type="email" required>
                  <button type="submit">Sign up</button>
                </form>
              </body>
            </html>
        "#))
    }

    async fn post(request: &Request) -> Result<Response, Error> {
        let form_data = request.form_data();
        let email = form_data.get::<String>("email");

        // Create the user
        Ok(Response::new().redirect("/welcome"))
    }
}
```

--------------------------------

### Basic Rwf Application Setup

Source: https://github.com/levkk/rwf/blob/main/README.md

This Rust code snippet demonstrates how to set up a minimal Rwf web application. It defines a simple controller function that returns an HTML response and configures the server to listen for requests on the root path.

```rust
use rwf::prelude::*;
use rwf::http::Server;

#[controller]
async fn index() -> Response {
    Response::new().html("<h1>Welcome to Rwf!</h1>")
}

#[tokio::main]
async fn main() {
    Server::new(vec![
        route!("/" => index),
    ])
    .launch()
    .await
    .unwrap();
}
```

--------------------------------

### Rwf Template Syntax Example

Source: https://github.com/levkk/rwf/blob/main/examples/dynamic-templates/README.md

Demonstrates basic Rwf template syntax including printing variables, loops, conditionals, and unescaped output.

```erb
<p><%= text %></p>

<ul>
<% for item in list %>
    <li><%= item.upcase %><li>
<% end %>
<ul>

<script>
<%- no_user_inputs_allowed_code %>
</script>

<% if value == "on" %>
    <p>Now you see me</p>
<% else %>
    <p>Now you don't</p>
<% end %>
```

--------------------------------

### Install Cargo Watch and Nextest

Source: https://github.com/levkk/rwf/blob/main/docs/docs/user-guides/index.md

Installs the necessary cargo extensions for improved local development workflows. cargo-watch monitors file changes and automatically restarts the server, while cargo-nextest provides a faster and more ergonomic testing experience.

```bash
cargo install cargo-watch cargo-nextest
```

--------------------------------

### Run Rwf Database Migrations

Source: https://github.com/levkk/rwf/blob/main/examples/orm/README.md

Provides an example of a Rust binary application to run Rwf database migrations. It initializes logging and calls the Migrations::migrate() function to apply pending schema changes.

```rust
use rwf::prelude::*;

#[tokio::main]
async fn main() {
    Logger::init();

    Migrations::migrate()
        .await
        .expect("migrations failed");
}
```

--------------------------------

### SQL Group By Query Example

Source: https://github.com/levkk/rwf/blob/main/docs/docs/models/grouping.md

An example SQL query demonstrating how to group data by hour and count records. This query calculates the number of users creating accounts each hour.

```sql
SELECT
    COUNT(*) AS count,
    DATE_TRUNC('hour', created_at) AS created_at
FROM users
GROUP BY 2
ORDER BY 2
```

--------------------------------

### Update User Output Example

Source: https://github.com/levkk/rwf/blob/main/docs/docs/controllers/REST/model-controller.md

Example JSON output for updating a user, showing the modified user object.

```json
{"id": 2, "email": "alice1@example.com", "admin": true}
```

--------------------------------

### Create Rwf Database Migration

Source: https://github.com/levkk/rwf/blob/main/docs/docs/user-guides/build-your-app/add-users.md

Uses the Rwf CLI to generate migration files for database schema changes. This command specifically creates files for a 'users' table migration.

```Shell
rwf-cli migrate add -n users
```

```Shell
rwf-cli migrate run
```

--------------------------------

### Rust REST Controller Implementation

Source: https://github.com/levkk/rwf/blob/main/docs/docs/controllers/REST/index.md

Demonstrates how to implement a REST controller in Rust using the 'rwf' framework. It shows the structure for defining resources and handling 'list' and 'get' operations.

```rust
use rwf::prelude::*;

#[derive(Default, macros::RestController)]
struct Users;

#[async_trait]
impl RestController for Users {
    // Users controller uses the primary key to identify resources.
    type Resource = i64;

    /// List all users.
    /// "GET /users"
    async fn list(&self, request: &Request) -> Result<Response, Error> {
        let users = serde_json::json!([
            {"id": 1, "email": "admin@example.com", "admin": true},
            {"id": 2, "email": "alice@example.com", "admin": false},
        ]);

        Ok(Response::new().json(users)?)
    }

    /// Get a particular user by identifier.
    /// "GET /users/<id>"
    async fn get(&self, request: &Request, id: &i64) -> Result<Response, Error> {
        let user = serde_json::json!({
            "id": *id,
            "email": "admin@example.com",
            "admin": true
        });

        Ok(Response::new().json(user)?)
    }

    /* Optionally implement other REST methods like create, update, patch, delete */
}

```

--------------------------------

### Down Migration Example

Source: https://github.com/levkk/rwf/blob/main/docs/docs/models/migrations.md

An example of a 'down' migration script that reverts the changes made by the corresponding 'up' migration, in this case, dropping the 'users' table.

```sql
DROP TABLE users;
```

--------------------------------

### Setup WebSocket Endpoint with Rwf

Source: https://github.com/levkk/rwf/blob/main/docs/docs/views/turbo/streams.md

Configures a WebSocket endpoint at '/turbo-stream' using Rwf's built-in TurboStream controller. This enables server-to-client communication for page updates.

```rust
use rwf::prelude::*;
use rwf::http::Server;
use rwf::controllers::TurboStream;

#[tokio::main]
async fn main() {
    Server::new(vec![
        route!("/turbo-stream" => TurboStream),
    ])
    .launch()
    .await
    .unwrap()
}
```

--------------------------------

### Rwf Global Functions

Source: https://github.com/levkk/rwf/blob/main/examples/dynamic-templates/README.md

Provides examples of using global utility functions for secure number encryption/decryption and for rendering essential head elements for Rwf frontends.

```RwfTemplate
<%= encrypt_number(25) %>
```

```RwfTemplate
<%= decrypt_number(encrypted) %>
```

```RwfTemplate
<head><%- rwf_head %></head>
```

--------------------------------

### Define Users Table Schema in SQL

Source: https://github.com/levkk/rwf/blob/main/docs/docs/user-guides/build-your-app/add-users.md

SQL statement to create the 'users' table in the database. It includes fields for a unique ID, username, password hash, and account creation timestamp.

```SQL
CREATE TABLE users (
    id BIGSERIAL PRIMARY KEY,
    username VARCHAR NOT NULL UNIQUE,
    password_hash VARCHAR NOT NULL,
    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
```

--------------------------------

### Define HTML Partial

Source: https://github.com/levkk/rwf/blob/main/docs/docs/views/templates/partials.md

A partial is a template file stored in a dedicated directory (e.g., `templates/partials`). This example shows a simple HTML navigation menu defined as a partial.

```html
<nav>
  <ul>
    <li><a href="/">Home</a></li>
    <li><a href="/profile">Profile</a></li>
  </ul>
</nav>
```

--------------------------------

### Get and Use Database Connection

Source: https://github.com/levkk/rwf/blob/main/docs/docs/models/connection-pool.md

Demonstrates how to check out a database connection from the pool for executing ORM queries. Connections are automatically returned when they go out of scope.

```rust
let mut conn = Pool::connection().await?;

let users = User::all()
    .fetch_all(&mut conn)
    .await?;
```

```rust
let users = {
    let mut conn = Pool::connection().await?;
    User::all()
        .fetch_all(&mut conn)
        .await?
};
```

--------------------------------

### Test Rwf Endpoint with cURL

Source: https://github.com/levkk/rwf/blob/main/docs/docs/controllers/index.md

Provides a command-line example using cURL to test a running Rwf server endpoint. This helps verify that the controller is correctly handling requests and returning the expected output.

```bash
curl localhost:8000/time -w '\n'
```

--------------------------------

### Basic Controller GET/POST Handling

Source: https://github.com/levkk/rwf/blob/main/docs/docs/controllers/pages.md

Demonstrates the manual approach to differentiating between GET and POST requests using a basic `Controller` trait. This method requires explicit conditional checks within a single `handle` method, leading to boilerplate code.

```rust
if request.get() {
    // Retrive page
} else if request.post() {
    // Handle form submission
} else {
    return Ok(Response::not_allowed());
}
```

--------------------------------

### Launch Rwf Server with Mapped Controllers

Source: https://github.com/levkk/rwf/blob/main/docs/docs/controllers/index.md

Demonstrates how to launch the Rwf server and map routes to controller implementations. The `Server::new` constructor takes a vector of routes, associating URL paths with controller instances.

```rust
use rwf::prelude::*;
use rwf::http::{self, Server};

#[tokio::main]
async fn main() -> Result<(), http::Error> {
    Server::new(vec![
        // Map the "/time" route to the `CurrentTime` controller.
        route!("/time" => CurrentTime),
    ])
    .launch()
    .await
}
```

--------------------------------

### List Users via Frontend JavaScript

Source: https://github.com/levkk/rwf/blob/main/docs/docs/controllers/REST/model-controller.md

Example of fetching a list of users from the backend using JavaScript's `fetch` API. Assumes the `Users` controller is mapped to the `/users` endpoint.

```javascript
let response = await fetch("/users");
const users = await response.json();

console.log(users)
```

--------------------------------

### Run Server with Cargo Watch

Source: https://github.com/levkk/rwf/blob/main/docs/docs/user-guides/index.md

Starts the development server and automatically restarts it whenever code changes are detected. This command leverages cargo-watch to streamline the development feedback loop by eliminating manual server restarts.

```bash
cargo watch --exec run
```

--------------------------------

### Rwf List Indexing

Source: https://github.com/levkk/rwf/blob/main/docs/docs/views/templates/variables.md

Illustrates accessing a specific element within a list using dot notation and zero-based indexing. This example retrieves the second element of a list.

```erb
<%= list.1 %>
```

--------------------------------

### Spawn a Background Job Worker

Source: https://github.com/levkk/rwf/blob/main/examples/background-jobs/README.md

Illustrates how to start a worker process that listens for and executes background jobs. Workers are typically Tokio tasks and can be configured with a list of job types they can handle.

```rust
use rwf::job::Worker;
use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() -> Result<(), JobError> {
    Worker::new(vec![
        SendEmail::default().job(),
    ])
    .start()
    .await?;

    // Keep the main process alive to allow workers to run
    sleep(Duration::MAX).await;
    Ok(())
}
```

--------------------------------

### Implement RestController for Manual Routing

Source: https://github.com/levkk/rwf/blob/main/examples/rest/README.md

Shows how to implement the `RestController` trait for manual handling of RESTful methods like `list` and `get`. Each method receives the request and potentially an ID, returning a `Response`.

```rust
#[derive(rwf::macros::RestController, Default)]
struct MyController;

#[rwf::async_trait]
impl RestController for MyController {
    type Resource = i64; // Use integers as the resource identifiers.
                         // Can be any other data type that implements `rwf::controller::ToParameter` trait.

    /// GET /
    async fn list(&self, _request: &Request) -> Result<Response, Error> {
        let result = serde_json::json!([
            {"id": 5, "email": "test@test.com"},
            {"id": 7, "email": "hello@test.com"},
        ]);

        Ok(Response::new().json(result)?)
    }

    /// GET /:id
    async fn get(&self, _request: &Request, id: &Self::Resource) -> Result<Response, Error> {
        let result = serde_json::json!({
            "id": *id,
            "email": "guest@test.com",
        });

        Ok(Response::new().json(result)?)
    }

    // All other methods will return HTTP 501.
}
```

--------------------------------

### REST API Operations

Source: https://github.com/levkk/rwf/blob/main/docs/docs/controllers/REST/index.md

Details the six fundamental HTTP methods used in RESTful APIs for resource manipulation, including their purpose, common endpoints, and example requests and responses.

```APIDOC
RESTful API Operations:

1. List (GET)
   - Purpose: Retrieve a collection of resources.
   - Endpoint: GET /endpoint
   - Example Request:
     curl localhost:8000/users
   - Example Response:
     [
       {"id": 1, "email": "admin@example.com", "admin": true},
       {"id": 2, "email": "first-user@example.com", "admin": false}
     ]

2. Get (GET)
   - Purpose: Retrieve a single resource by its unique identifier.
   - Endpoint: GET /endpoint/<id>
   - Parameters:
     - id: The unique identifier for the resource (e.g., number, UUID).
   - Example Request:
     curl localhost:8000/users/1
   - Example Response:
     {
       "id": 1,
       "email": "admin@example.com",
       "admin": false
     }

3. Create (POST)
   - Purpose: Create a new resource at the specified endpoint.
   - Endpoint: POST /endpoint
   - Parameters:
     - Request Body: Contains the resource definition (e.g., JSON payload).
   - Example Request:
     curl localhost:8000/users \
       -d '{"email": "alice@example.com", "admin": false}'
   - Example Response:
     {
       "id": 45,
       "email": "alice@example.com",
       "admin": false
     }

4. Update (PUT)
   - Purpose: Update an existing resource with new values.
   - Endpoint: PUT /endpoint/<id>
   - Parameters:
     - id: The unique identifier for the resource to update.
     - Request Body: Contains the complete updated resource definition.
   - Example Request:
     curl -X PUT localhost:8000/users/45 \
       -d '{"email": "alice1@example.com", "admin": false}'
   - Example Response:
     {
       "id": 45,
       "email": "alice1@example.com",
       "admin": false
     }

5. Patch (PATCH)
   - Purpose: Partially update an existing resource, applying only specified changes.
   - Endpoint: PATCH /endpoint/<id>
   - Parameters:
     - id: The unique identifier for the resource to update.
     - Request Body: Contains only the fields to be modified.
   - Example Request:
     curl -X PATCH localhost:8000/users/45 -d '{"admin": true}'
   - Example Response:
     {
       "id": 45,
       "email": "alice1@example.com",
       "admin": true
     }

6. Delete (DELETE)
   - Purpose: Remove a resource from the server.
   - Endpoint: DELETE /endpoint/<id>
   - Parameters:
     - id: The unique identifier for the resource to delete.
   - Example Request:
     curl -X DELETE localhost:8000/users/45
   - Example Response:
     (empty)

```

--------------------------------

### Get Absolute Value of Integer using abs in ERB

Source: https://github.com/levkk/rwf/blob/main/docs/docs/views/templates/functions/integer.md

Returns the absolute (non-negative) value of an integer. The example demonstrates passing a negative integer to the abs function.

```erb
<%= -5.abs %>
```

--------------------------------

### Database URL Format

Source: https://github.com/levkk/rwf/blob/main/docs/docs/configuration.md

Details the standard URL format for specifying database connections, as adopted from The Twelve Factor App methodology. This format is used for the `url` setting in the `[database]` section.

```apidoc
Database Connection URL Format:

`driver://user:password@host:port/database_name`

- `driver`: Specifies the database driver (e.g., `postgresql` or `postgres` for PostgreSQL).
- `user`: The username for database authentication.
- `password`: The password for database authentication.
- `host`: The database server hostname or IP address.
- `port`: The port number the database server is listening on.
- `database_name`: The name of the database to connect to.

Example for PostgreSQL:
`postgresql://myuser:mypassword@localhost:5432/mydatabase`
```

--------------------------------

### Define User Model in Rust

Source: https://github.com/levkk/rwf/blob/main/docs/docs/user-guides/build-your-app/add-users.md

Rust struct definition for the 'User' model, mapping to the database schema. It includes fields for id, username, password hash, and creation timestamp, with derive macros for Rwf model functionality.

```Rust
#[derive(Clone, macros::Model)]
pub struct User {
    id: Option<i64>,
    username: String,
    password_hash: String,
    created_at: OffsetDateTime,
}
```

--------------------------------

### ModelController CRUD Routes

Source: https://github.com/levkk/rwf/blob/main/examples/rest/README.md

Lists the standard CRUD routes automatically implemented by the `ModelController::crud` method. It includes GET for listing and fetching, POST for creating, and PUT/PATCH for updating resources.

```APIDOC
Path | Method | Description
---|---|---
`/api/users` | GET | List all users. Supports pagination, e.g. `?page_size=25&page=1`. Default page size is 25.
`/api/users/:id` | GET | Fetch a user by primary key.
`/api/users`| POST | Create a new user. All fields not marked optional or not having serde-specified defaults are required.
`/api/users/:id` | PUT | Update a user. Same requirement for fields as the create method above.
`/api/users/:id` | PATCH | Update a user. Only the fields that have changed can be supplied.
```

--------------------------------

### Generate Rwf Secret Key (Python)

Source: https://github.com/levkk/rwf/blob/main/docs/docs/configuration.md

Provides a Python script to generate a secure, base64-encoded secret key suitable for Rwf applications. This key is crucial for encryption and security features.

```python
import base64
import secrets

secret = base64.b64encode(secrets.token_bytes(int(256/8)))
print(secret)
```

--------------------------------

### Spawn Background Workers

Source: https://github.com/levkk/rwf/blob/main/docs/docs/background-jobs/index.md

Demonstrates how to create and start background workers that execute jobs from the queue. Workers are typically spawned in the `main` function using Tokio tasks. The `Worker::new` method initializes a worker with a list of jobs, and `worker.start()` begins processing.

```Rust
use rwf::job::Worker;
use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() -> Result<(), Error> {
    // Create a new worker with 4 threads.
    let worker = Worker::new(vec![
        WelcomeEmail::default().job()
    ])

    worker.start().await?;

    //  Put the main task to sleep indefinitely.
    sleep(Duration::MAX).await;
}
```

--------------------------------

### Rwf Hash Access

Source: https://github.com/levkk/rwf/blob/main/docs/docs/views/templates/variables.md

Demonstrates accessing values within a hash (key-value store) using dot notation. This example shows retrieving the 'name' and 'email' values from a 'user' hash.

```erb
<p><%= user.name %></p>
<p><%= user.email %></p>
```

--------------------------------

### Iterate Integer Times using times in ERB

Source: https://github.com/levkk/rwf/blob/main/docs/docs/views/templates/functions/integer.md

Creates a list of integers starting from 0 up to (but not including) the integer value. It's commonly used for loop constructs. The example iterates and prints each number.

```erb
<% for i in 3.times %>
    <%= i %>.
<% end %>
```

--------------------------------

### Run Django WSGI App with Rwf Server

Source: https://github.com/levkk/rwf/blob/main/docs/docs/migrating-from-python.md

Demonstrates how to initialize and launch an Rwf server with a WsgiController, mounting it to handle all requests at the root path.

```Rust
use rwf::prelude::*;
use rwf::http::Server;
use rwf::controller::WsgiController;

#[tokio::main]
async fn main() {
    Server::new(vec![
        WsgiController::new("project.wsgi")
            .wildcard("/"),
    ])
    .launch()
    .await
    .unwrap();
}
```

--------------------------------

### Package Rwf Application with CLI

Source: https://github.com/levkk/rwf/blob/main/docs/docs/user-guides/deploy-to-prod.md

Uses the Rwf CLI to package a Rust application for production. It bundles the binary, static files, templates, and migrations into a single archive.

```bash
rwf-cli package
```

--------------------------------

### Launch Rwf Server with Rails Rack Controller

Source: https://github.com/levkk/rwf/blob/main/docs/docs/migrating-from-rails.md

Demonstrates how to launch the Rwf server and integrate a Rails application using the `RackController`. The controller takes the path to the Rails app and can be configured to handle specific routes, like the wildcard '/'.

```rust
use rwf::prelude::*;
use rwf::http::{Server, self};
use rwf::controllers::RackController;

#[tokio::main]
async fn main() -> Result<(), http::Error> {
    Server::new(vec![ 
        RackController::new("path/to/your/rails/app")
            .wildcard("/")
    ])
    .launch()
    .await
}
```

--------------------------------

### Preload Admin Panel Templates and Static Files

Source: https://github.com/levkk/rwf/blob/main/docs/docs/user-guides/admin.md

Preloads the necessary templates and static files for the admin panel at runtime using `rwf_admin::install()`. This function should be called before launching the server to ensure the admin panel is correctly initialized.

```rust
use rwf::prelude::*;
use rwf::http::{Server, Error};

#[tokio::main]
async fn main() -> Result<(), Error> {
    // Preload templates and static files.
    rwf_admin::install()?;

    // Launch the server below.
    // ... server setup ...
    Ok(())
}
```

--------------------------------

### Basic Controller Implementation

Source: https://github.com/levkk/rwf/blob/main/examples/quick-start/README.md

Demonstrates how to create a basic controller by implementing the `rwf::controller::Controller` trait. This involves defining a struct and implementing the `handle` method to process incoming requests and return responses, typically HTML.

```rust
use rwf::prelude::*;

#[derive(Default)]
struct IndexController;

#[async_trait]
impl Controller for IndexController {
    async fn handle(&self, request: &Request) -> Result<Response, Error> {
        Ok(Response::new().html("
            <!DOCTYPE html>
            <html>
              <body>
                <h1>Hello</h1>
              </body
            >
        "))
    }
}
```

--------------------------------

### Demonstrate SQL Injection Prevention

Source: https://github.com/levkk/rwf/blob/main/docs/docs/models/security.md

Illustrates how the Rwf ORM handles potentially malicious input intended for SQL injection. It shows a Rust code example attempting to filter data with a harmful string, the resulting SQL query, and the error produced when the injected string is not a valid column name.

```Rust
let oops = User::all()
  .filter("\";DROP TABLE users;", 5)
  .fetch(&mut conn)
  .await?;
```

```SQL
SELECT * FROM "users" WHERE "\";DROP TABLE users;" = $1;
```

```Error
ERROR:  column "\";DROP TABLE users;" does not exist
```

--------------------------------

### View Rwf CLI Help

Source: https://github.com/levkk/rwf/blob/main/rwf-cli/README.md

Displays the help message for the Rwf CLI, listing all available commands and their options. This is useful for understanding the CLI's capabilities and how to use its various features.

```shell
$ rwf-cli --help

```

--------------------------------

### Initialize Rwf Logger (Rust)

Source: https://github.com/levkk/rwf/blob/main/docs/docs/logging.md

Demonstrates how to initialize the Rwf logging system using `Logger::init()`. This should be called only once in the application. It relies on the `tracing` crate.

```rust
use rwf::prelude::*;

#[tokio::main]
async fn main() {
    // Make sure to call this only once in your application.
    Logger::init();

    /* ... */
}
```

--------------------------------

### Get String Length (ERB)

Source: https://github.com/levkk/rwf/blob/main/docs/docs/views/templates/functions/string.md

Returns the length of the string.

```erb
<%= "hello".len %>
```

--------------------------------

### Define Simple Controller with #[controller] Macro

Source: https://github.com/levkk/rwf/blob/main/docs/docs/controllers/index.md

Demonstrates creating a basic controller using the `#[controller]` macro. This macro accepts an async function that returns a `Response`, simplifying controller creation for straightforward tasks.

```rust
#[controller]
async fn my_controller() -> Response {
    Response::new().html("<h1>My controller is working!</h1>")
}
```

--------------------------------

### Template Expression Example

Source: https://github.com/levkk/rwf/blob/main/docs/docs/views/templates/nomenclature.md

Demonstrates an expression combining arithmetic operators that evaluates to a single value in an ERB template.

```erb
<%= 5 * 2 / 10 %>
```

--------------------------------

### Get List Length in ERB

Source: https://github.com/levkk/rwf/blob/main/docs/docs/views/templates/functions/list.md

Returns the number of elements present in the list. This is a fundamental operation for understanding the size of a collection before processing it.

```erb
<%= [1, 2, 3].len %>
```

--------------------------------

### Analyze Query Performance with `explain()`

Source: https://github.com/levkk/rwf/blob/main/docs/docs/models/debug-queries.md

Obtain the database's query execution plan using the `explain()` method. This helps identify performance bottlenecks like sequential scans. Requires a database connection and the `explain()` method.

```Rust
let plan = User::find(15)
  .explain(&mut conn)
  .await?;
println!("{}", plan);
```

```SQL
EXPLAIN SELECT * FROM "users" WHERE "id" = $1
```

```Output
Seq Scan on users  (cost=0.00..25.00 rows=6 width=40)
Filter: (id = 5)
```

--------------------------------

### Get Absolute Value of Float (ERB)

Source: https://github.com/levkk/rwf/blob/main/docs/docs/views/templates/functions/float.md

Returns the absolute (non-negative) value of a floating-point number. This function is useful for ensuring a value is always positive.

```erb
<%= -5.0.abs %>
```

--------------------------------

### Get Hash Keys (ERB)

Source: https://github.com/levkk/rwf/blob/main/docs/docs/views/templates/functions/hash.md

Converts a hash to a list of its keys. This snippet shows how to iterate over the keys in an ERB template, using a Rust HashMap as context.

```erb
<% for fruit in fruits.keys %>
    <%= fruit %>
<% end %>
```

```rust
context!(
    "fruits" => HashMap::from([
        ("apples", "red"),
        ("bananas", "yellow")
    ])
);
```

--------------------------------

### Enable Basic HTTP Authentication in Rwf Controller

Source: https://github.com/levkk/rwf/blob/main/examples/auth/README.md

Demonstrates how to enable Basic HTTP authentication for a Rwf controller by implementing the `auth` method with `AuthHandler` and `BasicAuth`. This requires users to provide credentials via a prompt.

```rust
use rwf::controller::auth::{BasicAuth, AuthHandler};
use rwf::controller::Controller;
use rwf::http::{Request, Response};
use rwf::error::Error;

struct ProtectedController {
    auth: AuthHandler,
}

impl ProtectedController {
    fn new() -> ProtectedController {
        Self {
            auth: AuthHandler::new(BasicAuth {
                user: "admin".to_string(),
                password: "super-secret".to_string(),
            })
        }
    }
}

#[rwf::async_trait]
impl Controller for ProtectedController {
    /// Specify the authentication handler for this controller.
    fn auth(&self) -> &AuthHandler {
        &self.auth
    }

    async fn handle(&self, _request: &Request) -> Result<Response, Error> {
        Ok(Response::new().text("Welcome to the protected area!"));
    }
}
```

--------------------------------

### Create Record (Save)

Source: https://github.com/levkk/rwf/blob/main/examples/orm/README.md

Demonstrates creating a new database record by instantiating a model struct with an empty primary key and calling the `save()` method.

```rust
let user = User {
    id: None,
    email: "hello@test.com".into(),
    created_at: OffsetDateTime::now_utc(),
    admin: false,
};

let user = user
    .save()
    .fetch(&mut conn)
    .await?;
```

--------------------------------

### Template: Convert String to Uppercase

Source: https://github.com/levkk/rwf/blob/main/docs/docs/views/templates/functions/index.md

Demonstrates calling the `.upper` function on a string within an ERB template to convert it to uppercase. This is an example of a string manipulation function.

```erb
<%= "lowercase".upper %>
```

--------------------------------

### Render Dynamic Templates in Rust

Source: https://github.com/levkk/rwf/blob/main/docs/docs/views/templates/index.md

Demonstrates how to use the rwf crate to define and render dynamic templates with a context. It shows how to load a template string, create a context with variables, and render the final HTML output.

```Rust
use rwf::prelude::*;

let template = Template::from_str(r#"\
<div class=\"profile\">\
  <h2><%= username %></h2>\
  <p><%= bio %></p>\
</div>\"#)?;

let ctx = context!(
  "username" => "Alice",
  "bio" => "I like turtles"
);

let html = template.render(&ctx)?;

println!("{}", html);
```

```HTML
<div class="profile">
  <h2>Alice</h2>
  <p>I like turtles</p>
</div>
```

--------------------------------

### Get Hash Values (ERB)

Source: https://github.com/levkk/rwf/blob/main/docs/docs/views/templates/functions/hash.md

Converts a hash to a list of its values. This snippet demonstrates iterating over hash values in an ERB template, with a Rust HashMap provided as context.

```erb
<% for color in fruits.values %>
    <%= color %>
<% end %>
```

```rust
context!(
    "fruits" => HashMap::from([
        ("apples", "red"),
        ("bananas", "yellow")
    ])
);
```

--------------------------------

### Dockerfile for Rwf Application Deployment

Source: https://github.com/levkk/rwf/blob/main/docs/docs/user-guides/deploy-to-prod.md

A Dockerfile that builds an Rwf Rust application in a separate builder stage and then copies the compiled binary and assets to a minimal production image. This ensures a small and efficient production container.

```dockerfile
# Build the app in a separate container.
FROM rust:1-bullseye AS builder
COPY . /build
WORKDIR /build
RUN cargo build --release

# Production container using the same
# Linux distro.
FROM debian:bullseye

# Copy app from build container.
COPY --from=builder /build/target/release/app /app/app

# Copy assets.
COPY templates /app/templates
COPY static /app/static
COPY migrations /app/migrations

# Run the app.
WORKDIR /app
CMD ["app"]
```

--------------------------------

### Import Rwf Prelude Types

Source: https://github.com/levkk/rwf/blob/main/docs/docs/controllers/index.md

Imports essential types and traits from the `rwf::prelude` module. Including the prelude saves time and effort by making common components readily available for controller development.

```rust
use rwf::prelude::*;
```

--------------------------------

### Convert Integer to Float using to_float in ERB

Source: https://github.com/levkk/rwf/blob/main/docs/docs/views/templates/functions/integer.md

Converts an integer to a floating-point number. 'to_f' is an alias for this function. The example multiplies the converted float by another number.

```erb
<%= 5.to_float * 2.5 %>
```

--------------------------------

### Convert Integer to String using to_string in ERB

Source: https://github.com/levkk/rwf/blob/main/docs/docs/views/templates/functions/integer.md

Converts an integer to its string representation. 'to_s' is an alias for this function. The example concatenates the resulting string with additional text.

```erb
<%= 5.to_string + " times" %>
```

--------------------------------

### Connect REST Controllers to RWF Server (Rust)

Source: https://github.com/levkk/rwf/blob/main/docs/docs/controllers/REST/index.md

Shows how to launch an RWF server and connect REST controllers using the `rest!` macro. The `rest!` macro routes all six REST-style paths to the specified controller struct, which must implement the `Default` trait.

```rust
use rwf::prelude::*;
use rwf::http::Server;

#[tokio::main]
async fn main() {
    Server::new(vec![
        rest!("/users" => Users),
    ])
    .launch()
    .await
    .unwrap()
}
```

--------------------------------

### Get Hash Length (ERB)

Source: https://github.com/levkk/rwf/blob/main/docs/docs/views/templates/functions/hash.md

Returns the number of elements stored in the hash. This snippet shows how to display the length in an ERB template, using an empty Rust HashMap as context.

```erb
<%= fruits.len %>
```

```rust
context!(
    "fruits" => HashMap::new(),
);
```

--------------------------------

### Rwf Template Data Type Operations Reference

Source: https://github.com/levkk/rwf/blob/main/examples/dynamic-templates/README.md

Details the supported operations for various data types (Number, Float, String) within Rwf templates, including examples.

```APIDOC
Rwf Template Data Type Operations:

Number Operations:
  - `abs`: Get the absolute value. Example: `<%= 25.abs %>`
  - `to_string`, `to_s`: Convert to string. Example: `<% if 25.to_s == "25" %>`
  - `to_f`, `to_float`: Convert to float. Example: `<% if 25.to_f == 25.0 %>`
  - `times`: Create a range from 0 to the number. Example: `<% for i in 25.times %>`

Float Operations:
  - `abs`: Get the absolute value. Example: `<%= -25.0.abs %>`
  - `ceil`: Ceil to nearest integer. Example: `<% if 25.5.ceil == 26 %>`
  - `floor`: Floor to nearest integer. Example: `<% if 25.5.floor == 25 %>`
  - `round`: Round to nearest integer. Example: `<% if 25.5.round == 26 %>`
  - `to_string`, `to_s`: Convert to string. Example: `<%= 25.5.to_s %>`

String Operations:
  - `to_uppercase`, `upcase`: Convert to uppercase. Example: `<%= "hello".upcase %>`
  - `to_lowercase`, `downcase`: Convert to lowercase. Example: `<%= "BYE".downcase %>`
  - `trim`: Trim whitespace from ends. Example: `<%= " hello ".trim %>`
```

--------------------------------

### Cross-compile Rwf Application with CLI

Source: https://github.com/levkk/rwf/blob/main/docs/docs/user-guides/deploy-to-prod.md

Packages an Rwf application for a specific target architecture using the Rwf CLI. This is useful for deploying to servers with different CPU architectures than the development machine.

```bash
rwf-cli package --target aarch64-unknown-linux-gnu
```