Integra Web Framework

Integra is a sleek, performant web framework for Rust, harnessing the power of the hyper library.

GitHub repository

🌟 Features

• Fast: Built on top of hyper, one of the Rust's fastest web libraries.
• Explicit Routing: Define routes explicitly with a clear and intuitive router reminding you Laravel.
• Safety First: Benefit from Rust's strong safety guarantees.
• Minimalistic Design: No bloat, just the essentials.

🚀 Quickstart with Integra

1. Create a New Project

Start by creating a new Rust project. bash cargo new integra_project cd integra_project

2. Add Dependencies

Open Cargo.toml and add the following lines under [dependencies]: toml [dependencies] integra = { version = "0.0.5" } tokio = { version = "1", features = ["full"] } hyper = "0.14"

3. Setup Your Server

Setup your server in src/main.rs ```rust use hyper::{Server}; use std::net::SocketAddr; use std::convert::Infallible; use crate::routes::getallroutes; use integra::core::router::{ServiceWithRouter}; use std::sync::Arc; use hyper::service::makeservicefn;

mod app; mod routes;

[tokio::main(flavor = "current_thread")]

async fn main() { let router = getallroutes(); let shared_router = Arc::new(router);

let make_svc = make_service_fn(move |_conn| {
    let service = ServiceWithRouter { router: shared_router.clone() };
    async move { Ok::<_, Infallible>(service) }
});

let addr = SocketAddr::from(([127, 0, 0, 1], 3011));
let server = Server::bind(&addr).serve(make_svc);

if let Err(e) = server.await {
    eprintln!("server error: {}", e);
}

} ```

4. Define Your Routes

1. Define your modular routes in src/routes/app_routes.rs ```rust use integra::core::router::Route; use crate::app::{index, greet};

pub fn routes() -> Vec { vec![ Route::get("/", index), Route::get("/hello", greet) ] } 2. Include app_routes.rs in `src/routes/mod.rs` rust pub mod approutes; 3. Collect all routes in `src/web.rs` rust use crate::routes::approutes; use integra::core::router::Router; use integra::routes; use integra::route_collector;

pub fn getallroutes() -> Router { routecollector!( approutes ) }

```

5. Define Your App

Define your app for app_routes in src/app.rs ```rust use hyper::{Body, Request, Response};

pub async fn index(_req: Request) -> Response { Response::new(Body::from("Root path")) }

pub async fn greet(_req: Request) -> Response { Response::new(Body::from("Hello!")) } ```

📘 Usage

To-do

🎯 ROADMAP

• Routing system

  • [ ] Modules
  • ☐ Define application's structure using modules
  • ☐ Module encapsulation
  • ☐ Shared modules
  • [ ] Controllers
  • ☐ Route parameters
  • ☐ Request, Response objects handling
  • [ ] Supported requests
  • [x] GET
  • [ ] POST
  • [ ] PUT
  • [ ] DELETE
  • [ ] HEAD
  • [ ] CONNECT
  • [ ] OPTIONS
  • [ ] TRACE
  • [ ] PATCH
  • [ ] Middleware
  • ☐ Middleware for request/response manipulation
  • ☐ Execution order
  • [ ] Guards
  • ☐ Route guards for authentication and authorization
  • [ ] Interceptors
  • ☐ Transforming responses
  • ☐ Handling request/response lifecycle
  • [ ] Macro Attributes
  • ☐ Custom macro attributes for extracting custom data from requests

• Framework Architecture

  • [ ] Models
  • ☐ Integration with Diesel ORM
  • ☐ Support for migrations
  • ☐ CRUD operations
  • ☐ Advanced querying and filtering
  • [ ] Repositories
  • ☐ Generic Repository pattern
  • ☐ User Repository
  • [ ] Providers and Services
  • ☐ Custom providers
  • ☐ Singleton services
  • [ ] Views
  • ☐ Template engine integration
  • ☐ Support for dynamic content rendering
  • ☐ Layouts and partials

🤝 Contributing

To-do