### Setup RustF Project using Git Template

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/getting-started/installation.md

Clones the RustF sample application repository and copies its contents to a new project directory. This provides a pre-configured starting point for development.

```bash
# Clone the repository
git clone https://github.com/numerum-tech/rustf.git
cd rustf/sample-app

# Copy to your project
cp -r . /path/to/your/project
cd /path/to/your/project

# Install dependencies and run
cargo run
```

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

### Manual RustF Project Setup: src/controllers/home.rs

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/getting-started/installation.md

Defines a basic controller for the RustF application. This example sets up a GET route for the root path ('/') that returns an HTML response.

```rust
use rustf::prelude::*;

pub fn install() -> Vec<Route> {
    routes![
        GET "/" => index,
    ]
}

async fn index(ctx: &mut Context) -> Result<()> {
    ctx.html("<h1>Hello, RustF!</h1>")
}
```

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

### Manual RustF Project Setup: Cargo New

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/getting-started/installation.md

Initializes a new Rust project using Cargo and navigates into the project directory. This is the first step for manual RustF setup.

```bash
cargo new my-app
cd my-app
```

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

### Minimal TOML Configuration Example

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/guides/configuration.md

Presents a basic TOML configuration file for a RustF application, demonstrating the minimal setup required for server port and database URL, relying on default values for other settings.

```toml
# config.toml - Minimal configuration using defaults
[server]
port = 3000

[database]
url = "postgresql://localhost/myapp"
```

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

### Simple Home Controller Example

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/guides/controllers.md

Provides a complete example of a controller file (`src/controllers/home.rs`) demonstrating how to define routes and handler functions for the home page, about page, and contact page.

```APIDOC
## Simple Home Controller Example

### Description
An example controller file (`src/controllers/home.rs`) that defines routes for the home, about, and contact pages using the `routes!` macro and renders views with JSON data.

### Method
GET

### Endpoint
- `/`
- `/about`
- `/contact`

### Parameters
None

### Request Body
None

### Request Example
```rust
// src/controllers/home.rs
use rustf::prelude::*;

pub fn install() -> Vec<Route> {
    routes![
        GET "/" => index,
        GET "/about" => about,
        GET "/contact" => contact,
    ]
}

async fn index(ctx: &mut Context) -> Result<()> {
    let data = json!({
        "title": "Welcome to RustF",
        "message": "Your application is running successfully!",
        "features": [
            "Auto-discovery for controllers",
            "Template engine with layouts", 
            "Session management",
            "Built-in security features"
        ]
    });
    
    ctx.view("/home/index", data)
}

async fn about(ctx: &mut Context) -> Result<()> {
    let data = json!({
        "title": "About",
        "description": "Built with RustF framework - an AI-friendly MVC framework for Rust",
        "version": "1.0.0"
    });
    
    ctx.view("/home/about", data)
}

async fn contact(ctx: &mut Context) -> Result<()> {
    ctx.view("/home/contact", json!({
        "title": "Contact Us",
        "email": "info@example.com"
    }))
}
```

### Response
#### Success Response (200)
- **`view`** (string) - Path to the view template.
- **`data`** (JSON) - Data to be passed to the view.

#### Response Example
(View rendering depends on the template engine and data provided. Example for `/` endpoint):
```json
{
  "title": "Welcome to RustF",
  "message": "Your application is running successfully!",
  "features": [
    "Auto-discovery for controllers",
    "Template engine with layouts", 
    "Session management",
    "Built-in security features"
  ]
}
```
```

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

### RustF Application Lifecycle Setup

Source: https://github.com/numerum-tech/rustf/blob/main/book/book/guides/controllers.html

Shows the basic setup and startup of a RustF application. It demonstrates how to initialize the application, register controllers, add middleware, and start the HTTP server.

```rust
#![allow(unused_variables)]
#fn main() {
// 1. Application setup
let app = RustF::new()
    .controllers(auto_controllers!())  // Register all controllers
    .middleware("auth", AuthMiddleware::new());  // Add middleware

// 2. Server startup
app.start().await;  // Starts HTTP server

// 3. Request processing
// HTTP Request -> Middleware Chain -> Controller Handler -> HTTP Response
#}
```

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

### Rust: Import and Use RustF Utilities

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/api-reference/utilities.md

Demonstrates how to import the RustF prelude or the U module to access utility functions. Shows examples of direct and namespaced access for common tasks like generating GUIDs, encoding strings, getting HTTP status text, and hashing data.

```rust
use rustf::prelude::*;
// or
use rustf::U;

// Direct access - commonly used functions
let id = U::guid();
let encoded = U::encode("hello world");
let status = U::http_status(404); // "Not Found"
let hash = U::sha256("data");      // Secure hash function

// Namespaced access - extended functionality  
let slug = U::String::to_slug("Hello World!");
let html = U::Encoding::html_encode("<script>");
let duration = U::Parsing::parse_duration("1h", 0);
let md5_hash = U::Crypto::md5("data");  // Warning: Not secure
```

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

### CLI Commands - General Usage

Source: https://github.com/numerum-tech/rustf/blob/main/docs/ABOUT_CLI.md

Provides examples of common Rustf CLI commands for various development tasks, including project setup, analysis, and database operations.

```APIDOC
## Common CLI Commands

### Starting the Development Server
Enable writes for local development only.
```bash
rustf-cli serve start --allow-writes
```

### Setting Up a New Project
Guides through the process of creating a new Rustf project.
```bash
# 1. Create new project
rustf-cli new project my-app

# 2. Configure database
export DATABASE_URL="postgresql://user:pass@localhost/myapp"

# 3. Generate schemas from existing database
rustf-cli db generate-schema -o schemas

# 4. Generate models from schemas
rustf-cli schema generate models -o src/models

# 5. Create essential middleware
rustf-cli new middleware -n auth --auth --priority=-50
rustf-cli new middleware -n request-logger --logging --priority=-100

# 6. Start development server
cargo run
```

### Analyzing an Existing Project
Commands for inspecting and validating your project.
```bash
# Quick discovery
rustf-cli analyze discover

# Detailed project analysis
rustf-cli analyze project --detailed --format json

# Check for issues
rustf-cli validate

# Analyze routes for conflicts
rustf-cli analyze routes --conflicts-only
```

### Database-First Development
Workflow for managing database schemas and models.
```bash
# Test connection
rustf-cli db test-connection

# List tables
rustf-cli db list-tables --metadata

# Generate schemas from database
rustf-cli db generate-schema --force

# Generate models
rustf-cli schema generate models --force

# Verify consistency
rustf-cli schema check-consistency
```

### Creating Middleware Components
Examples for generating different types of middleware.
```bash
# Generate authentication middleware
rustf-cli new middleware -n auth --auth --priority=-50

# Generate logging middleware
rustf-cli new middleware -n request-logger --logging --priority=-100

# Generate rate limiting middleware
rustf-cli new middleware -n rate-limit --priority=-75

# Generate custom security headers middleware
rustf-cli new middleware -n security-headers --priority=100
```

### AI Agent Development
Commands for enabling AI-assisted development and remote analysis.
```bash
# For remote project analysis (safe)
rustf-cli serve start --bind 0.0.0.0

# For local AI-assisted development
rustf-cli serve start --allow-writes --watch
```
```

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

### Verify RustF Installation

Source: https://github.com/numerum-tech/rustf/blob/main/book/book/getting-started/installation.html

Commands to verify a RustF installation. It includes building the project, running tests, and starting the development server. Successful startup is indicated by a server running message.

```bash
# Build the project
cargo build

# Run tests
cargo test

# Start the server
cargo run

```

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

### Manual RustF Project Setup: config.toml

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/getting-started/installation.md

Configuration file for the RustF server. It specifies the server host and port, as well as settings for the view rendering engine.

```toml
[server]
host = "127.0.0.1"
port = 8000

[views]
directory = "views"
cache_enabled = false
```

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

### Manual RustF Project Setup - Project Structure

Source: https://github.com/numerum-tech/rustf/blob/main/book/book/getting-started/installation.html

Creates the essential directories for a manual RustF project setup. This includes directories for controllers, models, modules, middleware, views, static assets, and schemas.

```bash
mkdir -p src/controllers src/models src/modules src/middleware
mkdir -p views/layouts public/css public/js
mkdir -p schemas uploads
```

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

### Rust Controller Example

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/getting-started/project-structure.md

Controllers handle HTTP requests and define routes. Each controller file must export an `install()` function that returns a vector of `Route` objects, mapping HTTP methods and paths to handler functions.

```rust
use rustf::prelude::*;

pub fn install() -> Vec<Route> {
    routes![
        GET "/" => index,
        GET "/about" => about,
    ]
}

async fn index(ctx: &mut Context) -> Result<()> {
    ctx.view("home/index", json!({}))
}
```

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

### Create a New RustF Project using CLI

Source: https://github.com/numerum-tech/rustf/blob/main/book/book/getting-started/installation.html

Creates a new RustF project named 'my-app' using the installed RustF CLI, navigates into the project directory, and starts the development server. The CLI handles project structure, basic files, and auto-discovery.

```bash
# Create a new project
rustf-cli new project my-app

# Navigate to your project
cd my-app

# Run the server
cargo run
```

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

### Basic Routes Example

Source: https://github.com/numerum-tech/rustf/blob/main/book/book/api-reference/routing.html

Demonstrates how to define basic routes for GET requests in RustF.

```APIDOC
## Basic Routes

### Description
This example shows how to define simple routes for handling GET requests to different paths.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

### Code Example
```rust
# #![allow(unused_variables)]
# fn main() {
pub fn install() -> Vec<Route> {
    routes![
        GET "/" => index,
        GET "/about" => about,
    ]
}
# }
```
```

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

### Rust Supported HTTP Methods with routes! Macro and Manual Creation

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/guides/controllers.md

Illustrates how to define routes using the `routes!` macro for common HTTP methods (GET, POST, PUT, DELETE) and provides examples of manual route creation using `Route::get`, `Route::post`, etc.

```rust
// Available in routes! macro:
GET    "/path"     => handler_function
POST   "/path"     => handler_function  
PUT    "/path"     => handler_function
DELETE "/path"     => handler_function

// Manual route creation (rarely needed):
Route::get("/users", handler)           // GET request
Route::post("/users", handler)          // POST request
Route::put("/users/{id}", handler)       // PUT request
Route::delete("/users/{id}", handler)    // DELETE request
```

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

### Rust Basic Controller Structure with routes! Macro

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/guides/controllers.md

Demonstrates a basic RustF controller structure, including the required `install()` function that returns a `Vec<Route>` defined using the `routes!` macro. It also shows example async handler functions for different routes.

```rust
use rustf::prelude::*;

// Required: Every controller must have an install() function
pub fn install() -> Vec<Route> {
    routes![
        GET "/" => index,
        POST "/submit" => submit,
        GET "/item/{id}" => show_item,
    ]
}

// Handler functions - must be async and return Result<()>
async fn index(ctx: &mut Context) -> Result<()> {
    let data = json!({"message": "Welcome!"});
    ctx.view("/home/index", data)
}

async fn submit(ctx: &mut Context) -> Result<()> {
    let form_data = ctx.body_form()?;
    // Process form data
    ctx.redirect("/success")
}

async fn show_item(ctx: &mut Context) -> Result<()> {
    let item_id = ctx.param("id").unwrap_or("0").to_string();
    let data = json!({"id": item_id});
    ctx.json(data)
}
```

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

### TOML Example: Custom Application Configuration Sections

Source: https://github.com/numerum-tech/rustf/blob/main/docs/ABOUT_CONFIGURATION.md

An example of defining custom application configuration sections within a `config.toml` file. It shows how to structure application-specific settings like name, version, debug mode, and payment gateway details.

```toml
[app]
name = "MyApplication"
version = "1.0.0"
debug_mode = false

[payment]
stripe_key = "sk_test_xxxxx"
paypal_email = "business@example.com"

[smtp]
host = "smtp.gmail.com"
port = 587
user = "noreply@example.com"
password = "${SMTP_PASSWORD}"
```

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

### TOML Server Configuration Example

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/guides/configuration.md

Example TOML configuration for the server settings. This includes options for host, port, timeouts, SSL enablement and paths, and maximum concurrent connections.

```toml
[server]
host = "127.0.0.1"
port = 8000
timeout = 30
ssl_enabled = false
ssl_cert = "cert.pem"
ssl_key = "key.pem"
max_connections = 1000
```

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

### rustf-cli Output Formatting Examples

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/advanced/cli.md

Illustrates how to specify different output formats for rustf-cli commands, including table (default), JSON, YAML, and Markdown. Provides examples of redirecting output to files.

```bash
rustf-cli analyze project --format json > analysis.json
rustf-cli db list-tables --format yaml
```

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

### TOML Upload Configuration Example

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/guides/configuration.md

Example TOML configuration for file upload settings. Covers upload directory, maximum file size and count, allowed/blocked extensions, and directory creation.

```toml
[uploads]
directory = "uploads"
max_file_size = 10485760
max_files = 5
allowed_extensions = []
blocked_extensions = ["exe", "bat", "sh", "cmd"]
create_directories = true
```

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

### Rust Controller Installation Function

Source: https://github.com/numerum-tech/rustf/blob/main/CLAUDE.md

Example of a controller's `install` function in Rust, which is responsible for defining routes and their corresponding handler functions. It uses the `routes!` macro for concise route definition.

```rust
use rustf::prelude::*;

pub fn install() -> Vec<Route> {
    routes![
        GET "/" => index,
        POST "/" => create,
        GET "/:id" => show,
        PUT "/:id" => update,
        DELETE "/:id" => delete,
    ]
}

async fn index(ctx: Context) -> rustf::Result<Response> {
    // Handler implementation
    Ok(Response::json(json!({"status": "ok"}))?)
}
```

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

### Example Production TOML Configuration Override

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/guides/configuration.md

Shows an example of a `config.prod.toml` file used for production environment overrides, including changes to server settings, database URL from environment variables, and logging configuration.

```toml
# Production-specific overrides
environment = "production"

[server]
host = "0.0.0.0"
port = 80
ssl_enabled = true
ssl_cert = "/etc/ssl/certs/app.crt"
ssl_key = "/etc/ssl/private/app.key"
max_connections = 2000

[views]
cache_enabled = true

[session]
secret = "${SMTP_PASSWORD}"  # Read from environment
secure = true

[database]
url = "${DATABASE_URL}"  # Read from environment
max_connections = 20

[logging]
level = "warn"
file = "/var/log/rustf/app.log"

[custom]
api_endpoint = "https://api.production.com"
feature_x_enabled = "true"
```

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

### Create RustF Project using CLI or Cargo

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/getting-started/hello-world.md

Demonstrates two methods for creating a new RustF project: using the rustf-cli tool or the standard Cargo command.

```bash
rustf-cli new project hello-rustf
cd hello-rustf
```

```bash
cargo new hello-rustf
cd hello-rustf
```

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

### Clone and Run RustF Sample App

Source: https://github.com/numerum-tech/rustf/blob/main/book/book/getting-started/installation.html

Instructions for using the RustF sample application as a template. This involves cloning the repository, copying the sample app to a new project directory, and then running the application using Cargo.

```bash
# Clone the repository
git clone https://github.com/numerum-tech/rustf.git
cd rustf/sample-app

# Copy to your project
cp -r . /path/to/your/project
cd /path/to/your/project

# Install dependencies and run
cargo run

```

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

### Rust Event Handler Module Example

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/advanced/events.md

An example of an event handler module in RustF, showing how to install event listeners for database-related events. It includes functions for seeding development data and performing health checks.

```rust
// src/events/database.rs
use rustf::events::{EventEmitter, EventContext};

pub fn install(emitter: &mut EventEmitter) {
    emitter.on("database.ready", seed_development_data);
    emitter.on("ready", database_health_check);
}

async fn seed_development_data(ctx: EventContext) -> rustf::Result<()> {
    if ctx.is_development() {
        println!("Seeding development data...");
        // Database seeding logic
    }
    Ok(())
}

async fn database_health_check(ctx: EventContext) -> rustf::Result<()> {
    println!("Running database health check...");
    // Health check logic
    Ok(())
}
```

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

### Running RustF Example Application

Source: https://github.com/numerum-tech/rustf/blob/main/CLAUDE.md

Instructions to navigate to the example application directory and run it using Cargo. Also provides the default access URL.

```bash
# Run the example application
cd rustf-example
cargo run

# Access at http://127.0.0.1:8000
```

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

### Initialize RustF Project using CLI

Source: https://github.com/numerum-tech/rustf/blob/main/book/book/getting-started/README.html

This snippet demonstrates how to create a new RustF project using the framework's command-line interface (CLI) tool. It requires the rustf-cli to be installed and accessible in the system's PATH.

```bash
# 1. Create a new project using the CLI
rustf-cli new project my-app

# 2. Navigate to your project
cd my-app

# 3. Run the server
cargo run
```

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

### Rustf CLI: Setting Up a New Project Workflow

Source: https://github.com/numerum-tech/rustf/blob/main/book/book/advanced/cli.html

A step-by-step guide to setting up a new project using the Rustf CLI. This includes creating a new project, configuring the database, generating schemas and models, creating essential middleware, and starting the development server.

```bash
# 1. Create new project
rustf-cli new project my-app

# 2. Configure database in config.toml or .env
export DATABASE_URL="postgresql://user:pass@localhost/myapp"

# 3. Generate schemas from existing database
rustf-cli db generate-schema -o schemas

# 4. Generate models from schemas
rustf-cli schema generate models -o src/models

# 5. Create essential middleware
rustf-cli new middleware -n auth --auth --priority=-50
rustf-cli new middleware -n request-logger --logging --priority=-100

# 6. Start development server
cargo run
```

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

### Rust Nested Controller Example

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/getting-started/project-structure.md

Demonstrates how to define nested routes within a controller, allowing for organized API endpoints. The `install()` function returns routes prefixed with a common path segment.

```rust
use rustf::prelude::*;

pub fn install() -> Vec<Route> {
    routes![
        GET "/api/users" => list_users,
        GET "/api/users/{id}" => get_user,
    ]
}
```

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

### Maintain Type Safety with Session Get (Rust)

Source: https://github.com/numerum-tech/rustf/blob/main/SESSION_ACCESS_GUIDE.md

Highlights the importance of type-safe access to session data. The example shows how directly accessing session data can lose type information, returning a generic `Value`. Using `session_get::<T>()` ensures type safety.

```rust
// ❌ Bad - Loses type information
let session = ctx.session()?;
let user_id = session.data.get("user_id"); // Returns Value

// ✅ Good - Type-safe access
let user_id: Option<i64> = ctx.session_get("user_id");
```

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

### Manual Project Setup for RustF

Source: https://github.com/numerum-tech/rustf/blob/main/README.md

This snippet outlines the manual steps to set up a RustF project. It involves creating a new Cargo project, adding necessary dependencies like `tokio`, `serde`, `log`, and `env_logger`. Note that `rustf` itself would be added from crates.io or a local path.

```bash
cargo new my-app && cd my-app
cargo add tokio --features="full" serde --features="derive" serde_json log env_logger
# Note: Add rustf from crates.io after publication, or use --path for local development
```

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

### Install RustF CLI

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/getting-started/installation.md

Installs the RustF Command Line Interface tool. This involves cloning the repository, navigating to the CLI directory, and building/installing the package using Cargo.

```bash
git clone https://github.com/numerum-tech/rustf.git
cd rustf/rustf-cli

# Build and install
cargo install --path .
```

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

### Rust Application Entry Point

Source: https://github.com/numerum-tech/rustf/blob/main/book/book/getting-started/project-structure.html

The main.rs file serves as the application's entry point. It initializes logging, sets up the RustF application with controllers and middleware, and starts the server.

```rust
use rustf::prelude::*;

#[tokio::main]
async fn main() -> rustf::Result<()> {
    env_logger::init();
    
    let app = RustF::new()
        .controllers(auto_controllers!())
        .middleware_from(auto_middleware!());
    
    app.start().await
}
```

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

### Complete Navigation Example (HTML)

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/guides/database.md

A full HTML example demonstrating how to render pagination controls using the `pagination` object in a template.

```APIDOC
## Complete Navigation Example

```html
<!-- Full pagination with first/last links -->
<div class="pagination">
    <!-- First & Previous -->
    @{if !pagination.isFirst}
        <a href="@{pagination.first.url}">« First</a>
    @{fi}
    
    @{if pagination.isPrev}
        <a href="@{pagination.prev.url}">‹ Previous</a>
    @{else}
        <span class="disabled">‹ Previous</span>
    @{fi}
    
    <!-- Page Numbers -->
    @{foreach page in pagination.range}
        @{if page.selected}
            <span class="current">@{page.page}</span>
        @{else}
            <a href="@{page.url}">@{page.page}</a>
        @{fi}
    @{end}
    
    <!-- Next & Last -->
    @{if pagination.isNext}
        <a href="@{pagination.next.url}">Next ›</a>
    @{else}
        <span class="disabled">Next ›</span>
    @{fi}
    
    @{if !pagination.isLast}
        <a href="@{pagination.last.url}">Last »</a>
    @{fi}
</div>

<!-- Page info -->
<p>Page @{pagination.page} of @{pagination.count} 
   (@{pagination.items} total items)</p>
```
```

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

### Simple Home Controller Example in Rust

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/guides/controllers.md

Provides a complete example of a simple home controller in RustF. It defines routes for the index, about, and contact pages, and renders views with JSON data. This controller assumes the existence of corresponding view files in the `/home/` directory. Dependencies include `rustf::prelude::*` and `serde_json::json`.

```rust
// src/controllers/home.rs
use rustf::prelude::*;

pub fn install() -> Vec<Route> {
    routes![
        GET "/" => index,
        GET "/about" => about,
        GET "/contact" => contact,
    ]
}

async fn index(ctx: &mut Context) -> Result<()> {
    let data = json!({
        "title": "Welcome to RustF",
        "message": "Your application is running successfully!",
        "features": [
            "Auto-discovery for controllers",
            "Template engine with layouts", 
            "Session management",
            "Built-in security features"
        ]
    });
    
    ctx.view("/home/index", data)
}

async fn about(ctx: &mut Context) -> Result<()> {
    let data = json!({
        "title": "About",
        "description": "Built with RustF framework - an AI-friendly MVC framework for Rust",
        "version": "1.0.0"
    });
    
    ctx.view("/home/about", data)
}

async fn contact(ctx: &mut Context) -> Result<()> {
    ctx.view("/home/contact", json!({
        "title": "Contact Us",
        "email": "info@example.com"
    }))
}
```

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

### Basic Rust Module Structure with install()

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/advanced/modules.md

Defines the basic structure for a Rustf module, including a struct `UserService` and an `install()` function. The `install()` function is crucial for auto-discovery by the framework and returns an instance of the module.

```rust
// src/modules/user_service.rs
use rustf::prelude::*;

#[derive(Debug)]
pub struct UserService {
    name: String,
}

impl UserService {
    pub fn new() -> Self {
        Self {
            name: "UserService".to_string(),
        }
    }
    
    /// Register a new user with business logic validation
    pub async fn register_user(&self, email: &str, password: &str, profile: Value) -> Result<Value> {
        // Input validation
        if email.is_empty() || !email.contains('@') {
            return Err(Error::validation("Invalid email format"));
        }
        
        if password.len() < 8 {
            return Err(Error::validation("Password must be at least 8 characters"));
        }
        
        // Business logic implementation
        let user = json!({
            "user_id": 1,
            "email": email,
            "created_at": chrono::Utc::now(),
            "is_verified": false
        });
        
        Ok(user)
    }
}

// Required for auto-discovery
pub fn install() -> UserService {
    UserService::new()
}
```

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

### TOML Static Files Configuration Example

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/guides/configuration.md

Example TOML configuration for serving static files. Defines the directory for static assets, the URL prefix, and caching-related settings.

```toml
[static_files]
directory = "public"
url_prefix = "/static"
cache_enabled = true
cache_max_age = 86400
```

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

### Profiling with Cargo Instruments (Bash)

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/advanced/performance.md

Instructions for installing and using `cargo-instruments` for profiling Rust applications. It demonstrates how to install the tool and run a time profiling template.

```bash
cargo install cargo-instruments
cargo instruments --template time
```

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

### Run RustF Application

Source: https://github.com/numerum-tech/rustf/blob/main/sample-app/README.md

Commands to install dependencies, run the application in development mode, and build for production. Assumes Rust and Cargo are installed.

```bash
# Install dependencies and run
car go run

# The server will start at http://127.0.0.1:8000
# Visit the URL to see your application
```

```bash
# Run in development mode with hot reloading
car go run
```

```bash
# Build for production
car go build --release
```

```bash
# Run tests
car go test
```

```bash
# Format code
car go fmt
```

```bash
# Check for issues
car go clippy
```

```bash
# Build optimized binary
car go build --release

# Run with production config
RUSTF_ENV=production ./target/release/sample-app
```

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

### TOML Session Configuration Example

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/guides/configuration.md

Example TOML configuration for session management. Includes settings for the secret key, timeout, cookie name, security flags, and storage backend details.

```toml
[session]
secret = "change-me-in-production"
timeout = 3600
cookie_name = "rustf_session"
secure = false
http_only = true

[session.storage]
type = "memory"
cleanup_interval = 300
```

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

### Base Configuration Example (config.toml)

Source: https://github.com/numerum-tech/rustf/blob/main/docs/ABOUT_RUSTF.md

This TOML snippet provides a comprehensive example of a base configuration file (`config.toml`) for a RustF application. It includes settings for the server, views, sessions, static files, database, CORS, logging, uploads, and custom application parameters.

```toml
# config.toml (base configuration)
environment = "development"

[server]
host = "127.0.0.1"
port = 8000
timeout = 30
max_connections = 1000
ssl_enabled = false

[views]
directory = "views"
default_layout = "layouts/default"
cache_enabled = false
extension = "html"
engine = "tera"  # "tera", "filesystem", "embedded", "auto"

[session]
secret = "your-secret-key-here"
timeout = 3600
cookie_name = "rustf_session"
secure = false
http_only = true

[session.storage]
type = "memory"
cleanup_interval = 300

# Redis session storage (requires "redis" feature)
# [session.storage]
# type = "redis"
# url = "redis://localhost:6379"
# prefix = "rustf:session:"
# pool_size = 10

[static_files]
directory = "public"
url_prefix = "/static"
cache_enabled = true
cache_max_age = 86400

[database]
url = "postgresql://user:pass@localhost/dbname"
max_connections = 10
timeout = 30

[cors]
enabled = false
allowed_origins = ["*"]
allowed_methods = ["GET", "POST"]
allowed_headers = ["Content-Type"]

[logging]
level = "info"
# file = "app.log"  # Optional log file

[uploads]
directory = "uploads"
max_file_size = 10485760  # 10MB
max_files = 5
blocked_extensions = ["exe", "bat", "sh", "cmd"]
create_directories = true

[custom]
# Custom application-specific settings
app_name = "My RustF App"
api_version = "v1"
```

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

### TOML Views Configuration Example

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/guides/configuration.md

Example TOML configuration for the template engine (views) settings. It specifies the template directory, default layout, caching, file extension, and storage method.

```toml
[views]
directory = "views"
default_layout = "layouts/default"
cache_enabled = false
extension = "html"
storage = "filesystem"
```

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

### Application Startup with Automatic Configuration Loading (Rust)

Source: https://github.com/numerum-tech/rustf/blob/main/book/book/guides/configuration.html

Demonstrates how RustF automatically initializes configuration during application startup. It shows the use of `#[rustf::auto_discover]` and `RustF::with_args()` for loading configuration with CLI support, along with alternative loading methods.

```rust
use rustf::prelude::*;

#[rustf::auto_discover]
#[tokio::main]
async fn main() -> Result<()> {
    // Configuration is loaded and CONF is initialized automatically
    let app = RustF::with_args()?;  // Loads config with CLI support
    
    // Alternative loading methods:
    // let app = RustF::new();                    // Default config
    // let app = RustF::from_file("config.toml")?; // Specific file
    // let app = RustF::from_env()?;              // Environment only
    // let app = RustF::with_config(my_config);   // Programmatic
    
    app.start().await
}
```

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

### RustF Application Setup with Automatic Discovery and SharedRegistry

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/advanced/modules.md

Illustrates initializing a RustF application using the `#[rustf::auto_discover]` attribute, which automatically handles module discovery, registration with SharedRegistry, and initialization during app startup.

```rust
// src/main.rs
use rustf::prelude::*;

#[rustf::auto_discover]
#[tokio::main]
async fn main() -> Result<()> {
    let app = RustF::new()
        .controllers(auto_controllers!())
        .models(auto_models!())
        .modules_from(auto_modules!())  // Registers and initializes modules
        .start().await  // Calls initialize_all() automatically
}
```

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

### Application Setup with RustF Auto-Discovery

Source: https://github.com/numerum-tech/rustf/blob/main/docs/ABOUT_RUSTF.md

This Rust code snippet demonstrates how to set up a RustF application using auto-discovery macros to register controllers, models, and middleware. It relies on the `rustf::prelude::*` and `tokio` crates.

```rust
// src/main.rs
use rustf::prelude::*;

// Auto-discovery uses build-time macros to scan and include components:
// 1. Scans src/controllers/*.rs, src/models/*.rs, src/modules/*.rs at compile time
// 2. Generates module declarations and registration code
// 3. Creates IDE support files (_controllers.rs, _models.rs, etc.)
// Note: Uses procedural macros, not attributes

#[tokio::main]
async fn main() -> rustf::Result<()> {
    env_logger::init();
    
    let app = RustF::new()
        .controllers(auto_controllers!())  // Auto-discover all controllers
        .models(auto_models!())           // Auto-register all models
        .middleware_from(auto_middleware!()); // Auto-register middleware
    
    app.start().await
}
```

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

### TOML Production Configuration Example

Source: https://github.com/numerum-tech/rustf/blob/main/book/src/getting-started/project-structure.md

An example of a TOML configuration file for production environment overrides. It modifies server host and port, enables view caching, and configures session security.

```toml
[server]
host = "0.0.0.0"
port = 8080

[views]
cache_enabled = true

[session]
secure = true
```

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

### Example 2: Search with Pagination

Source: https://github.com/numerum-tech/rustf/blob/main/docs/QUERY_BUILDER.md

This example shows how to construct a query to search for posts using LIKE clauses, order the results, and implement pagination.

```APIDOC
### Example 2: Search with Pagination

```rust
let search_term = "%rust%";
let page = 2;

let posts = db.query()
    .select(vec!["id", "title", "content", "author_id", "created_at"])
    .from("posts")
    .where_like("title", &search_term)
    .or_where_like("content", &search_term)
    .where_eq("published", true)
    .order_by("created_at", OrderDirection::Desc)
    .paginate(page, 20)
    .build()?;
```
```