rustauth-fred 0.2.0

Fred-backed Redis and Valkey integrations for RustAuth.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

# rustauth-fred

Redis and Valkey integrations for RustAuth using `fred`.

## What It Is

`rustauth-fred` provides the same Redis-compatible RustAuth integration points
as `rustauth-redis`, but through the `fred` client. Use it when your
application already uses `fred` or wants Valkey/Redis support through that
client ecosystem.

## Naming

RustAuth storage backends share one vocabulary:

| Type | Role |
|------|------|
| `FredStores` | Rate limit + secondary storage sharing one `fred` client |
| `FredOptions` | Connection options for both stores |
| `apply_to_options` | Wire both stores into [`RustAuthOptions`] |

`FredRustAuthStores` and `FredRustAuthOptions` are type aliases kept for
migration.

## What It Provides

- `FredStores`: one shared `fred` client for rate limiting and secondary storage
  (recommended entry point).
- `FredRateLimitStore`: distributed atomic rate limiting through Lua.
- `FredSecondaryStorage`: secondary key-value storage for sessions,
  verification state, SSO state, and plugin data.
- `list_keys()` / `clear()` on secondary storage (`SCAN`, not `KEYS`).
- Redis and Valkey URL normalization (internal; pass `valkey://` URLs directly
  to `connect`).
- Optional `native-tls` and `rustls` feature flags forwarded to `fred`.

## Quick Start

```rust
use rustauth::{RustAuth, RustAuthOptions};
use rustauth_fred::FredStores;

let stores = FredStores::connect("valkey://127.0.0.1:6379").await?;

let auth = RustAuth::builder()
    .options(stores.apply_to_options(
        RustAuthOptions::new().secret("secret-a-at-least-32-chars-long!!"),
    ))
    .build()?;
# let _ = auth;
# Ok::<(), Box<dyn std::error::Error>>(())
```

`apply_to_options` wires both `secondary_storage` and distributed rate limiting
in one call.

### Individual store

```rust
use rustauth::{RustAuth, RateLimitOptions};
use rustauth_fred::FredRateLimitStore;

let store = FredRateLimitStore::connect("redis://127.0.0.1:6379").await?;

let auth = RustAuth::builder()
    .secret("secret-a-at-least-32-chars-long!!")
    .rate_limit(
        RateLimitOptions::secondary_storage(store)
            .enabled(true)
            .window(60)
            .max(100),
    )
    .build()?;
# let _ = auth;
# Ok::<(), Box<dyn std::error::Error>>(())
```

Secondary storage uses raw string values and TTLs in seconds. Operational
helpers such as `list_keys()` and `clear()` use `SCAN` instead of `KEYS`.

## Status

Experimental beta. URL handling, key layout, Lua script behavior, and
rate-limit/secondary-storage contracts may change before stable release.

## Better Auth compatibility

Server-side Redis/Valkey secondary storage and rate limiting via `fred`. Aligned
with Better Auth **1.6.9** where it matters for this crate; RustAuth is not a
line-by-line port.

For route-level parity, test counts, intentional differences, and known gaps, see
[UPSTREAM.md](./UPSTREAM.md).

## Links

- [Sibling crate `rustauth-redis`](../rustauth-redis/README.md)
- [Root README](../../README.md)
- [Repository](https://github.com/salasebas/rustauth)