Function app 

pub fn app() -> App

Creates a new Express-style application instance.

This is the main entry-point for the framework, equivalent to calling express() in Node.js.

Example

use expressjs::prelude::*;

#[expressjs::main]
async fn main() {
    let mut app = express();
    app.get("/", async |_req, res| res.send_text("Hello, world!"));
    app.listen(3000, async |port| println!("Listening on port {port}")).await;
}

Initializes a new express application.

Examples found in repository

examples/hello_world.rs (line 5)

async fn main() {
    let mut app = express();

    app.get("/", async |_req, res| res.send_text("Hello World!"));

    app.listen(9000, async |port| {
        println!("🚀 Server running on http://localhost:{port}/");
    })
    .await;
}

examples/json.rs (line 6)

async fn main() {
    let mut app = express();

    app.get("/json", async |_req, res| {
        res.send_json(&json!({
            "status": "success",
            "message": "Hello from JSON!",
            "data": {
                "id": 1,
                "name": "Aragorn",
                "role": "King"
            }
        }))
    });

    app.listen(9000, async |port| {
        println!("🚀 Server running on http://localhost:{port}/json");
    })
    .await;
}

examples/routing.rs (line 5)

async fn main() {
    let mut app = express();

    // Static route
    app.get("/", async |_req, res| res.send_text("Welcome!"));

    // Route with one parameter
    app.get("/users/{id}", async |req, res| {
        let id = req.params().get("id").unwrap_or("unknown");
        res.send_text(format!("User ID: {id}"))
    });

    // Route with multiple parameters
    app.get(
        "/posts/{post_id}/comments/{comment_id}",
        async |req, res| {
            let post_id = req.params().get("post_id").unwrap_or("unknown");
            let comment_id = req.params().get("comment_id").unwrap_or("unknown");
            res.send_text(format!("Post ID: {post_id}, Comment ID: {comment_id}"))
        },
    );

    // Catch-all (glob)
    app.get("/static/{*path}", async |req, res| {
        let path = req.params().get("path").unwrap_or("");
        res.send_text(format!("Serving file from: {path}"))
    });

    app.listen(9000, async |port| {
        println!("🚀 Server running on http://localhost:{port}/");
    })
    .await;
}

examples/middleware.rs (line 6)

async fn main() {
    let mut app = express();

    // Global middleware: Cors
    app.use_global(CorsMiddleware::permissive());

    // Global middleware: Normalize path
    app.use_global(NormalizePathMiddleware::new());

    // Route-specific middleware (using prefix)
    app.use_with("/api", |req: &mut Request, _res: &mut Response| {
        let path = req.uri().path().to_owned();
        async move {
            println!("API middleware triggered for: {}", path);
            next_res()
        }
    });

    app.get("/api/v1", async |_req, res| res.send_text("API Response"));

    // Header manipulation in middleware (global logging)
    app.use_global(LoggingMiddleware);

    // Dynamic middleware logic
    app.use_global(|req: &mut Request, res: &mut Response| {
        let uri = req.uri().to_string();
        res.header("X-Custom-Global", HeaderValue::from_static("Enabled"));
        async move {
            println!("Custom global middleware for: {}", uri);
            next_res()
        }
    });

    app.get("/hello", async |_req, res| res.send_text("Hello!"));

    app.listen(9000, async |port| {
        println!("🚀 Server running on http://localhost:{port}/");
    })
    .await;
}

examples/basic.rs (line 37)

async fn main() {
    setup_logger().unwrap();

    const PORT: u16 = 9000;
    let mut app = express();

    // Middleware
    app.use_global(NormalizePathMiddleware::new())
        .use_global(CorsMiddleware::permissive())
        .use_global(LoggingMiddleware)
        .use_with("/css/{*p}", StaticServeMiddleware::new("."))
        .use_with("/expressjs_tests/{*p}", StaticServeMiddleware::new("."));

    // Routes

    // GET / - index page
    app.get("/", async |_req, res| {
        let html = r#"
        <!DOCTYPE html>
        <html lang="en">
        <head>
            <meta charset="UTF-8">
            <meta name="viewport" content="width=device-width, initial-scale=1.0">
            <title>Welcome</title>
            <link rel="stylesheet" href="/css/index.css"/>
        </head>
        <body>
            <h1>Welcome to expressjs</h1>
            <p>This is a minimal HTML page served from Rust.</p>
            <ul>
                <li><a href="/json">JSON Endpoint</a></li>
                <li><a href="/redirect">Redirect to Home</a></li>
                <li><a href="status">Trigger 400</a></li>
                <li><a href="hello">Say Hello</a></li>
            </ul>
        </body>
        </html>
        "#;

        res.status_code(200)
            .content_type("text/html; charset=utf-8")
            .send_html(html)
    });

    // GET /count - request counter
    app.get("/count", async |_req, res| {
        let count = STATE.request_count.fetch_add(1, Ordering::Relaxed);

        res.send_json(&json!({
            "request_count": count,
            "message": "Request count retrieved successfully"
        }))
    });

    // GET /json - static JSON response
    app.get("/json", async |_req, res| {
        res.header(
            hyper::header::CACHE_CONTROL,
            HeaderValue::from_static("public, max-age=3600"),
        )
        .send_json(&json!({
            "message": "Hello from JSON!",
            "status": "success",
            "version": "1.0"
        }))
    });

    // GET /redirect - redirect to /
    app.get("/redirect", async |_req, res| res.redirect("/"));

    // GET /status - always 400
    app.get("/status", async |_req, res| {
        res.status_code(400).send_text("400 Bad Request")
    });

    // GET /status/:status - echo status param
    app.get("/status/{status}", async |req, res| {
        let value = req.params().get("status").unwrap_or("unknown");
        res.send_text(format!("Status is {value}"))
    });

    // GET /file - stream Cargo.lock (async, borrows res across await)
    app.get("/file", async |_req, res| {
        res.send_file("./Cargo.lock").await
    });

    // /hello - X-Powered-By middleware then response
    // app.use_with("/hello", async |_req: &mut Request, res: &mut Response| {
    //     res.header("x-powered-by", HeaderValue::from_static("DevYatsu"));
    //     stop_res()
    // });

    app.get("/hello", async |_req, res| {
        res.body("Hello, world!")
            .header(
                header::CACHE_CONTROL,
                HeaderValue::from_static("public, max-age=86400"),
            )
            .header(header::CONTENT_TYPE, HeaderValue::from_static("text/html"))
    });

    // Route builder pattern - multiple methods on the same path
    app.route("/api/v1/user")
        .get(async |_req, res| res.send_text("Get User"))
        .post(async |_req, res| res.send_text("Post User"));

    // all() - matches every HTTP method
    app.all("/ping", async |_req, res| res.send_text("pong"));

    // Custom 404 handler
    app.not_found(async |_req, res| {
        res.status_code(404)
            .send_text("Custom 404: Page not found!")
    });

    // Listen
    app.listen(PORT, async |port| {
        let local_ip = local_ip().unwrap();
        info!("🚀 Server running!");
        info!("📍 Local:   http://localhost:{port}/");
        info!("🌐 Network: http://{local_ip}:{port}/");
    })
    .await
}