Compose. Run. Scale. The application composition layer for Rust.APIs.workers.CLIs.devices.

use std::io::{self, BufRead};

use rustclamp::prelude::*;

fn main() {
    Clamp::run(|| {
        println!("Clamp TUI. Type a line, or `quit` to exit.");
        for line in io::stdin().lock().lines().map_while(Result::ok) {
            if line.trim() == "quit" {
                break;
            }
            println!("you said: {line}");
        }
    });
}

use rustclamp::config::Config;
use rustclamp_core::{LifecycleContext, Module, ModuleId, Start, Stop};

struct Mailer {
    per_day: u32,
    running: bool,
}

impl Module for Mailer {
    const ID: ModuleId = ModuleId::new("app.mailer");
}

impl Start for Mailer {
    type Error = String;

    fn start(&mut self, _: &LifecycleContext) -> Result<(), String> {
        self.running = true;
        Ok(())
    }
}

impl Stop for Mailer {
    type Error = String;

    fn stop(&mut self, _: &LifecycleContext) -> Result<(), String> {
        self.running = false; // drained before this runs
        Ok(())
    }
}

let config = Config::load();
let mailer = Mailer { per_day: config.get_or("MAIL_PER_DAY", 300), running: false };

use std::time::Duration;

use rustclamp::prelude::*;
use rustclamp::web::{self, Router, Sessions, csrf, json, redirect, throttle};

fn routes() -> Router {
    Router::new()
        .view("/", "welcome")
        .group(|site| {
            site.middleware(Sessions::new(Duration::from_secs(7200)).middleware())
                .middleware(csrf())
                .post("/contact", |request| {
                    let name = request.form("name").unwrap_or_default();
                    if let Some(session) = request.session() {
                        session.put("flash", &format!("Thanks, {name}!"));
                    }
                    redirect("/")
                })
        })
        .group(|api| {
            api.middleware(throttle(60, Duration::from_secs(60)))
                .get("/api/health", |_| json(r#"{"status":"ok"}"#))
        })
}

fn main() {
    Clamp::run(|| web::serve(routes()));
}

// The payload is decoded before the handler runs; one that does not decode never reaches it.
let handler = HandlerDeclaration::typed(SUBJECT, 1, |email: EmailPayload, _| async move {
    println!("delivered email to {}: {}", email.to, email.subject);
    Ok(())
});

let catch_up_job = JobDeclaration::new(
    "cleanup-expired-sessions",
    Duration::from_secs(10),
    MisfirePolicy::RunOnce,
    || async {
        println!("cleanup operation invoked");
        Ok(())
    },
);

#![no_std]
#![forbid(unsafe_code)]

extern crate alloc;

use rustclamp_core::ModuleId;

pub struct Thermometer;

impl rustclamp_core::Module for Thermometer {
    const ID: ModuleId = ModuleId::new("example.platform-neutral.thermometer");
}