Rust

cargo add reqwest@0.12 --features json
cargo add serde_json
cargo add tokio --features macros,rt-multi-thread,time

use serde_json::{json, Value};
use std::{env, time::Duration};

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let runtime_url = env::var("FORMERIE_RUNTIME_URL").unwrap_or("https://forms.formerie.com".into());
    // Your form. This is the only line that names it.
    let form = env::var("FORMERIE_FORM").unwrap_or("acme/contact".into());

    let client = reqwest::Client::builder().timeout(Duration::from_secs(10)).build()?;
    let response = client
        .post(format!("{runtime_url}/{form}/submit"))
        .json(&json!({
            "fields": {
                "name": "Jane Example",
                "email": "jane@example.com",
                "message": "Hello from my server",
            },
        }))
        .send()
        .await?;
    let status = response.status();
    let result: Value = response.json().await?;
    println!("{status} {}", result["submissionUid"].as_str().or(result["error"]["code"].as_str()).unwrap_or(""));
    Ok(())
}

use serde_json::{json, Value};
use std::{env, time::Duration};

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let runtime_url = env::var("FORMERIE_RUNTIME_URL").unwrap_or("https://forms.formerie.com".into());
    // Your form. This is the only line that names it.
    let form = env::var("FORMERIE_FORM").unwrap_or("acme/contact".into());
    // Keep the key out of your code. A test is stored apart and emails nobody.
    let test_key = env::var("FORMERIE_TEST_KEY").expect("FORMERIE_TEST_KEY isn't set");

    let client = reqwest::Client::builder().timeout(Duration::from_secs(10)).build()?;
    let response = client
        .post(format!("{runtime_url}/{form}/submit"))
        .header("X-Formerie-Test-Key", test_key)
        .json(&json!({
            "fields": { "name": "Jane Example", "email": "jane@example.com", "message": "Just a test" },
        }))
        .send()
        .await?;
    let status = response.status();
    let result: Value = response.json().await?;
    println!("{status} {}", result["submissionUid"].as_str().or(result["error"]["code"].as_str()).unwrap_or(""));
    Ok(())
}

use serde_json::{json, Value};
use std::{env, time::Duration};

/// Checks answers and stores nothing. With no step, only the fields you send are checked.
async fn check_answers(client: &reqwest::Client, fields: Value, step: Option<&str>) -> Result<Value, Box<dyn std::error::Error>> {
    let runtime_url = env::var("FORMERIE_RUNTIME_URL").unwrap_or("https://forms.formerie.com".into());
    // Your form. This is the only line that names it.
    let form = env::var("FORMERIE_FORM").unwrap_or("acme/contact".into());

    let body = match step {
        Some(step) => json!({ "mode": "step", "step": step, "fields": fields }),
        None => json!({ "mode": "partial", "fields": fields }),
    };
    let result: Value = client.post(format!("{runtime_url}/{form}/validate")).json(&body).send().await?.json().await?;
    if result["ok"] != true && result["error"]["code"] != "VALIDATION_FAILED" {
        return Err(format!("formerie: {}", result["error"]["code"]).into());
    }
    Ok(result)
}

use serde_json::{json, Value};
use std::{env, time::Duration};

async fn submit_answers(client: &reqwest::Client, fields: &Value) -> Result<Value, reqwest::Error> {
    let runtime_url = env::var("FORMERIE_RUNTIME_URL").unwrap_or("https://forms.formerie.com".into());
    // Your form. This is the only line that names it.
    let form = env::var("FORMERIE_FORM").unwrap_or("acme/contact".into());
    client.post(format!("{runtime_url}/{form}/submit")).json(&json!({ "fields": fields })).send().await?.json().await
}

fn escape_html(text: &str) -> String {
    text.replace('&', "&amp;").replace('<', "&lt;").replace('>', "&gt;").replace('"', "&quot;").replace('\'', "&#39;")
}

/// Finds the visitor's answer for a path such as contact.email, so the form can show it again.
fn answer_at<'a>(answers: &'a Value, path: &str) -> &'a str {
    path.split('.').fold(answers, |value, part| &value[part]).as_str().unwrap_or("")
}

/// One input with its answer kept and its first message under it.
fn render_field(path: &str, answers: &Value, result: &Value) -> String {
    let error = match result["error"]["fields"][path][0]["message"].as_str() {
        Some(message) => format!(r#"<p class="error">{}</p>"#, escape_html(message)),
        None => String::new(),
    };
    format!(r#"<input name="{}" value="{}">{error}"#, escape_html(path), escape_html(answer_at(answers, path)))
}

use rand::Rng;
use serde_json::{json, Value};
use std::{env, time::Duration};

const MAX_ATTEMPTS: u32 = 3;
const LONGEST_WAIT: u64 = 30;

/// One attempt. Says what happened, and whether another attempt could help.
async fn send_once(client: &reqwest::Client, fields: &Value, key: &str) -> (Value, bool, Option<u64>) {
    let runtime_url = env::var("FORMERIE_RUNTIME_URL").unwrap_or("https://forms.formerie.com".into());
    // Your form. This is the only line that names it.
    let form = env::var("FORMERIE_FORM").unwrap_or("acme/contact".into());

    let response = client
        .post(format!("{runtime_url}/{form}/submit"))
        .json(&json!({ "fields": fields, "metadata": { "idempotencyKey": key } }))
        .send()
        .await;
    let response = match response {
        Ok(response) => response,
        Err(_) => return (json!({ "outcome": "retry-later", "reason": "network" }), true, None),
    };
    let status = response.status().as_u16();

    // Only the short-term limit sends Retry-After. A form's own limit can last an hour, so don't wait for it.
    if status == 429 {
        let after: Option<u64> = response.headers().get("Retry-After").and_then(|value| value.to_str().ok()?.parse().ok());
        let again = after.is_some_and(|seconds| seconds <= LONGEST_WAIT);
        return (json!({ "outcome": "retry-later", "reason": "rate-limited", "after": after }), again, after);
    }

    // Something in front of Formerie may answer without JSON, so look at the status first.
    let result: Value = match response.json().await {
        Ok(result) => result,
        Err(_) => {
            let again = matches!(status, 502 | 503 | 504);
            return (json!({ "outcome": "retry-later", "reason": "bad-response" }), again, None);
        }
    };

    if result["ok"] == true {
        return (json!({ "outcome": "accepted", "id": result["submissionUid"] }), false, None);
    }
    let error = &result["error"];
    match error["code"].as_str().unwrap_or("") {
        // The first send worked, and only its answer was lost.
        "DUPLICATE_SUBMISSION" => (json!({ "outcome": "accepted", "duplicate": true }), false, None),
        code @ ("FORM_MAINTENANCE" | "QUEUE_FAILED" | "INTERNAL_ERROR") => {
            (json!({ "outcome": "retry-later", "reason": code }), true, None)
        }
        "VALIDATION_FAILED" => (json!({ "outcome": "invalid", "code": error["code"], "issues": error["issues"] }), false, None),
        _ => (json!({ "outcome": "rejected", "code": error["code"], "message": error["message"] }), false, None),
    }
}

/// One key per submission, the same on every retry. Store it with the answers if you retry later.
async fn submit_with_retries(client: &reqwest::Client, fields: &Value, key: &str) -> Value {
    let mut attempt = 1;
    loop {
        let (mut answer, again, after) = send_once(client, fields, key).await;
        if !again || attempt == MAX_ATTEMPTS {
            answer["key"] = json!(key);
            answer["attempts"] = json!(attempt);
            return answer;
        }
        let backoff = rand::rng().random_range(0..=(250u64 << attempt).min(4_000));
        tokio::time::sleep(Duration::from_millis(backoff.max(after.unwrap_or(0) * 1_000))).await;
        attempt += 1;
    }
}

use serde_json::{json, Value};
use std::{env, time::Duration};

/// posted is what your form sent. origin is the Origin header of the visitor's request.
async fn submit_verified(client: &reqwest::Client, mut posted: Value, origin: &str) -> Result<Value, reqwest::Error> {
    let runtime_url = env::var("FORMERIE_RUNTIME_URL").unwrap_or("https://forms.formerie.com".into());
    // Your form. This is the only line that names it.
    let form = env::var("FORMERIE_FORM").unwrap_or("acme/contact".into());

    let token = posted.as_object_mut().and_then(|fields| fields.remove("cf-turnstile-response"));
    let mut request = client
        .post(format!("{runtime_url}/{form}/submit"))
        .json(&json!({ "fields": posted, "verificationToken": token }));
    // Without the visitor's Origin, the provider's hostname can't match, and the check fails.
    if !origin.is_empty() {
        request = request.header("Origin", origin);
    }
    request.send().await?.json().await
}

use chrono::{DateTime, SecondsFormat, Utc};
use serde_json::{json, Value};
use std::{env, time::Duration};

async fn submit_with_metadata(
    client: &reqwest::Client,
    fields: &Value,
    started_at: DateTime<Utc>,
    visitor_id: &str,
) -> Result<Value, reqwest::Error> {
    let runtime_url = env::var("FORMERIE_RUNTIME_URL").unwrap_or("https://forms.formerie.com".into());
    // Your form. This is the only line that names it.
    let form = env::var("FORMERIE_FORM").unwrap_or("acme/contact".into());

    client
        .post(format!("{runtime_url}/{form}/submit"))
        .json(&json!({
            "fields": fields,
            "metadata": {
                "idempotencyKey": uuid::Uuid::new_v4().to_string(),
                // When the visitor opened the form, for the minimum submit time check.
                "startedAt": started_at.to_rfc3339_opts(SecondsFormat::Secs, true),
                "pageUrl": "https://www.example.com/contact",
                // Your own visitor ID, for a limit rule with the deviceToken scope.
                "deviceToken": visitor_id,
            },
        }))
        .send()
        .await?
        .json()
        .await
}