init

Author: jetemail

.github/workflows/ci.yml

@@ -0,0 +1,59 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  check:
+    name: Check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo check
+
+  check-blocking:
+    name: Check (blocking)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo check --features blocking --no-default-features --features native-tls
+
+  test:
+    name: Tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo test
+
+  fmt:
+    name: Format
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt
+      - run: cargo fmt --all --check
+
+  clippy:
+    name: Clippy
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo clippy --all-targets -- -D warnings

.gitignore

@@ -0,0 +1,19 @@
+# Build artifacts
+/target/
+
+# Cargo lock (library crate)
+Cargo.lock
+
+# Editor/IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Environment
+.env

Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "jetemail"
+version = "0.1.0"
+edition = "2021"
+description = "Rust SDK for the JetEmail API"
+license = "MIT"
+repository = "https://github.com/jetemail/jetemail-rust"
+keywords = ["email", "jetemail", "api"]
+categories = ["api-bindings", "email"]
+
+[dependencies]
+reqwest = { version = "0.13", default-features = false, features = ["json"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+thiserror = "2"
+maybe-async = "0.2"
+base64 = "0.22"
+
+[dev-dependencies]
+tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
+
+[features]
+default = ["native-tls"]
+blocking = ["reqwest/blocking", "maybe-async/is_sync"]
+native-tls = ["reqwest/native-tls"]
+rustls = ["reqwest/rustls"]

README.md

@@ -1,2 +1,141 @@
-# jetemail-rust
-JetEmail Rust SDK
+# JetEmail Rust SDK
+
+The official Rust SDK for the [JetEmail](https://jetemail.com) email API.
+
+## Installation
+
+Add to your `Cargo.toml`:
+
+```toml
+[dependencies]
+jetemail = "0.1"
+```
+
+## Usage
+
+### Send an email
+
+```rust
+use jetemail::{CreateEmailOptions, JetEmail};
+
+#[tokio::main]
+async fn main() -> jetemail::Result<()> {
+    let client = JetEmail::new("je_your_api_key");
+
+    let email = CreateEmailOptions::new(
+        "you@example.com",
+        "recipient@example.com",
+        "Hello from JetEmail!",
+    )
+    .with_html("<h1>Hello World!</h1>");
+
+    let response = client.emails.send(email).await?;
+    println!("Email sent! ID: {}", response.id);
+
+    Ok(())
+}
+```
+
+### Send to multiple recipients
+
+```rust
+let email = CreateEmailOptions::new(
+    "you@example.com",
+    vec!["alice@example.com".into(), "bob@example.com".into()],
+    "Hello everyone!",
+)
+.with_html("<p>Hi there!</p>")
+.with_cc("cc@example.com")
+.with_bcc("bcc@example.com")
+.with_reply_to("reply@example.com");
+```
+
+### Send with attachments
+
+```rust
+use jetemail::Attachment;
+
+let email = CreateEmailOptions::new(
+    "you@example.com",
+    "recipient@example.com",
+    "Email with attachment",
+)
+.with_html("<p>See attached.</p>")
+.with_attachment(Attachment::from_content(b"file contents", "file.txt"))
+.with_attachment(Attachment::from_path("./report.pdf")?);
+```
+
+### Send batch emails
+
+Send up to 100 emails in a single API call:
+
+```rust
+let emails = vec![
+    CreateEmailOptions::new("you@example.com", "alice@example.com", "Hello Alice!")
+        .with_html("<p>Hi Alice!</p>"),
+    CreateEmailOptions::new("you@example.com", "bob@example.com", "Hello Bob!")
+        .with_html("<p>Hi Bob!</p>"),
+];
+
+let response = client.batch.send(emails).await?;
+```
+
+### Custom headers
+
+```rust
+let email = CreateEmailOptions::new(
+    "you@example.com",
+    "recipient@example.com",
+    "With custom headers",
+)
+.with_html("<p>Hello!</p>")
+.with_header("X-Custom-Header", "custom-value");
+```
+
+## Configuration
+
+### Environment variable
+
+```rust
+// Uses JETEMAIL_API_KEY environment variable
+let client = JetEmail::default();
+```
+
+### Advanced configuration
+
+Use `ConfigBuilder` for full control over the client. This lets you override the API base URL (useful for testing against a local or staging server), set a custom user agent, or provide your own `reqwest` client with custom timeouts or proxy settings.
+
+```rust
+use jetemail::ConfigBuilder;
+
+let config = ConfigBuilder::new("je_your_api_key")
+    .base_url("https://staging-api.jetemail.com") // default: https://api.jetemail.com
+    .user_agent("my-app/1.0")
+    .client(
+        reqwest::Client::builder()
+            .timeout(std::time::Duration::from_secs(30))
+            .build()
+            .unwrap(),
+    )
+    .build();
+
+let client = JetEmail::with_config(config);
+```
+
+## Blocking Usage
+
+Enable the `blocking` feature for synchronous usage:
+
+```toml
+[dependencies]
+jetemail = { version = "0.1", features = ["blocking"] }
+```
+
+```rust
+let client = JetEmail::new("je_your_api_key");
+let response = client.emails.send(email)?;
+```
+
+## License
+
+MIT

examples/send_batch.rs

@@ -0,0 +1,20 @@
+use jetemail::{CreateEmailOptions, JetEmail};
+
+#[tokio::main]
+async fn main() -> jetemail::Result<()> {
+    let client = JetEmail::new("je_your_api_key");
+
+    let emails = vec![
+        CreateEmailOptions::new("you@example.com", "alice@example.com", "Hello Alice!")
+            .with_html("<p>Hi Alice!</p>"),
+        CreateEmailOptions::new("you@example.com", "bob@example.com", "Hello Bob!")
+            .with_html("<p>Hi Bob!</p>"),
+    ];
+
+    let response = client.batch.send(emails).await?;
+    for email in &response.data {
+        println!("Sent email ID: {}", email.id);
+    }
+
+    Ok(())
+}

examples/send_email.rs

@@ -0,0 +1,18 @@
+use jetemail::{CreateEmailOptions, JetEmail};
+
+#[tokio::main]
+async fn main() -> jetemail::Result<()> {
+    let client = JetEmail::new("je_your_api_key");
+
+    let email = CreateEmailOptions::new(
+        "you@example.com",
+        "recipient@example.com",
+        "Hello from JetEmail!",
+    )
+    .with_html("<h1>Hello World!</h1><p>Sent with JetEmail Rust SDK.</p>");
+
+    let response = client.emails.send(email).await?;
+    println!("Email sent! ID: {}", response.id);
+
+    Ok(())
+}

examples/with_attachments.rs

@@ -0,0 +1,21 @@
+use jetemail::{Attachment, CreateEmailOptions, JetEmail};
+
+#[tokio::main]
+async fn main() -> jetemail::Result<()> {
+    let client = JetEmail::new("je_your_api_key");
+
+    let email = CreateEmailOptions::new(
+        "you@example.com",
+        "recipient@example.com",
+        "Email with attachment",
+    )
+    .with_html("<p>Please see the attached file.</p>")
+    .with_attachment(Attachment::from_content(b"Hello, World!", "hello.txt"))
+    .with_cc("cc@example.com")
+    .with_reply_to("reply@example.com");
+
+    let response = client.emails.send(email).await?;
+    println!("Email sent! ID: {}", response.id);
+
+    Ok(())
+}

src/batch.rs

@@ -0,0 +1,46 @@
+use std::sync::Arc;
+
+use serde::Deserialize;
+
+use crate::config::Config;
+use crate::emails::{CreateEmailOptions, CreateEmailResponse};
+use crate::error::Result;
+
+/// Response from sending a batch of emails.
+#[derive(Clone, Debug, Deserialize)]
+pub struct BatchEmailResponse {
+    /// The responses for each email in the batch.
+    pub data: Vec<CreateEmailResponse>,
+}
+
+/// Service for sending batch emails via the JetEmail API.
+#[derive(Clone, Debug)]
+pub struct BatchSvc(pub(crate) Arc<Config>);
+
+impl BatchSvc {
+    /// Send a batch of emails (up to 100).
+    #[maybe_async::maybe_async]
+    pub async fn send(&self, emails: Vec<CreateEmailOptions>) -> Result<BatchEmailResponse> {
+        if emails.is_empty() {
+            return Err(crate::error::Error::JetEmail {
+                message: "Batch must contain at least one email".into(),
+                status_code: 0,
+                response: None,
+            });
+        }
+        if emails.len() > 100 {
+            return Err(crate::error::Error::JetEmail {
+                message: "Batch cannot contain more than 100 emails".into(),
+                status_code: 0,
+                response: None,
+            });
+        }
+
+        let body = serde_json::json!({ "emails": emails });
+        let response = self
+            .0
+            .send(reqwest::Method::POST, "/email-batch", Some(body))
+            .await?;
+        serde_json::from_value(response).map_err(|e| crate::error::Error::Parse(e.to_string()))
+    }
+}