# Servme

Un framework web HTTP de bajo nivel escrito en Rust, construido sobre Hyper.

## Características

- **Middleware System**: Pipeline extensible para autenticación (JWT, API Key, IP Filter)
- **Builder Pattern**: API fluente para configuración del servidor
- **Graceful Shutdown**: Manejo elegante de señales SIGINT/SIGTERM
- **Error Handling**: Sistema de errores tipado con `ServerError`
- **High Performance**: IP filtering con O(1) lookups usando HashSet

## Uso Básico

```rust
use servme::{ServerBuilder, Responder, UrlExtract};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let server = ServerBuilder::new()
        .address("127.0.0.1", 8080)
        .handler(|req, res| async {
            let url = UrlExtract::new(req.uri());
            Responder::ok(format!("Hello, {}!", url.param_str("name").unwrap_or_default()))
        })
        .build();

    server.run().await
}
```

## Middlewares

### API Key Authentication

```rust
use servme::{ServerBuilder, middleware::ApiKeyMiddleware};

let server = ServerBuilder::new()
    .address("127.0.0.1", 8080)
    .add_api_key_middleware("your-secret-key")
    .build();
```

### JWT Authentication

```rust
use servme::{ServerBuilder, middleware::JwtMiddleware};

let server = ServerBuilder::new()
    .address("127.0.0.1", 8080)
    .add_jwt_middleware("your-secret-key")
    .build();
```

### IP Filtering

```rust
use servme::{ServerBuilder, middleware::IpFilterMiddleware};

let server = ServerBuilder::new()
    .address("127.0.0.1", 8080)
    .add_ip_filter_middleware(
        vec!["192.168.1.1".to_string(), "10.0.0.1".to_string()],
        true  // allow private IPs
    )
    .build();
```

## Constantes Disponibles

```rust
use servme::constants::{
    DEFAULT_HOST,      // "127.0.0.1"
    DEFAULT_PORT,      // 8080
    JWT_COOKIE_NAME,   // "access_token"
    BEARER_PREFIX,     // "Bearer "
    FILE_EXTENSIONS,   // [".json", ".html", ".css", ".js"]
    MAX_ALLOWED_IPS,   // 1000
};
```

## Responder Helpers

```rust
use servme::Responder;

// JSON response
Responder::json(&data)?;

// Redirect
Responder::redirect("/new-location")?;

// Status codes
Responder::not_found()?;
Responder::unauthorized()?;
Responder::forbidden()?;
Responder::bad_request("error message")?;
Responder::internal_error("error message")?;
```

## Construcción y Tests

```bash
# Build
cargo build

# Run tests
cargo test

# Run with debug logging
RUST_LOG=debug cargo run
```

## Estructura del Proyecto

```
src/
├── lib.rs              # Exports públicos
├── main.rs             # Binario de ejemplo
├── builder.rs          # ServerBuilder
├── config.rs           # ServerConfig
├── server.rs           # Servidor HTTP con graceful shutdown
├── error.rs            # ServerError enum
├── constants.rs        # Constantes configurables
├── responder.rs        # Helper para construir respuestas
├── requester.rs        # Helper para extraer request info
├── url_extract.rs      # URL parsing y query params
└── middleware/
    ├── mod.rs          # Traits y tipos comunes
    ├── api_key.rs      # API Key authentication
    ├── jwt.rs          # JWT authentication
    ├── ip_filter.rs    # IP filtering
    └── auth_types.rs   # Tipos de autenticación
```

## License

MIT