dink-sdk 0.3.1

# dink-sdk

Rust SDK for the [Dink](https://github.com/ozanturksever/dink) edge mesh platform.

Dink connects edge devices to cloud services over NATS using JSON-based RPC. This crate provides the client libraries and traits needed to build edges and centers in Rust.

## Quick Start

```toml
[dependencies]
dink-sdk = "0.1"
```

### Edge Worker

```rust
use dink_sdk::{edge_worker, ServiceHandler};
use std::sync::Arc;

// Implement a generated service trait
struct MySensor;

#[async_trait::async_trait]
impl SensorServiceServer for MySensor {
    async fn read_temperature(&self, _req: ReadTemperatureRequest) -> dink_sdk::Result<Temperature> {
        Ok(Temperature {
            value: 22.5,
            unit: "celsius".into(),
            timestamp: String::new(),
        })
    }
    // ...
}

#[tokio::main]
async fn main() -> dink_sdk::Result<()> {
    let handler = Arc::new(SensorServiceHandler::new(MySensor)) as Arc<dyn ServiceHandler>;
    edge_worker(vec![handler]).await
}
```

Set `DINK_EDGE_KEY` (or `DINK_API_KEY`) and `DINK_SERVER_URL` environment variables.

### Center Client

```rust
use dink_sdk::{CenterClient, CenterConfig};

#[tokio::main]
async fn main() -> dink_sdk::Result<()> {
    let client = CenterClient::connect(CenterConfig {
        server_url: "nats://localhost:4222".into(),
        api_key: Some("dk_live_ed_myapp_edge1_secret".into()),
        ..Default::default()
    }).await?;

    let sensor = SensorServiceClient::new("edge-123".into(), client);
    let temp = sensor.read_temperature(&ReadTemperatureRequest {}).await?;
    println!("{}°{}", temp.value, temp.unit);
    Ok(())
}
```

## Code Generation

Generate typed Rust clients and handlers from `.proto` service definitions:

```bash
dink codegen --lang rust --proto ./contracts --rust-output ./gen/rust
```

This produces:
- `types.rs` — Rust structs for all proto messages
- `{service}_dink.rs` — Server trait, Client struct, Handler dispatch, ServiceDefinition const

## Features

- **Edge client** — connect, expose services, peer/group RPC, presence lifecycle
- **Center client** — call edges, discover, stream, key management
- **Code generation** — typed clients and handlers from proto definitions
- **Streaming** — server-streaming RPC with cancel support
- **Auth** — NATS token auth with edge key parsing (legacy + base64 format)

## License

MIT