hadead 0.1.2

Redis Rate Limiter using wallexerr
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




# 📛 Had

Redis Rate Limiter with Crypto Wallets as the Unique Identifier.

> Make sure that you've filled up the env vars inside `.env` file, also make sure you've installed the wallexerr crate using ```cargo add wallexerr```.

## 🚀 Run

```bash
cargo run --bin had
```

## 📦 Publish

```bash
cargo login
cargo publish --dry-run
cargo publish
```

## 🧪 Test

```rust
use hadead::*;
use once_cell::sync::Lazy;

pub static HADEAD: Lazy<Config> = Lazy::new(||{

    let redis_password = "REDIS_PASSWORD".to_string();
    let redis_username = "REDIS_USERNAME".to_string();
    let redis_host = "REDIS_HOST".to_string();
    let redis_port = "REDIS_PORT".to_string();
    let chill_zone_duration_in_seconds = 5;

    let hadead_instance = hadead::Config{
        redis_host,
        redis_port,
        redis_password: Some(redis_password),
        redis_username: None,
        chill_zone_duration_in_seconds, /* default is 5 miliseconds */
        id: None
    };

    hadead_instance

});

pub async fn api() -> Result<actix_web::HttpResponse, actix_web::Error>{

    let hadead = HADEAD.clone();
    let check_rate_limited = hadead.check(hadead.id.as_ref().unwrap()).await;
    
    let Ok(flag) = check_rate_limited else{
        
        let why = check_rate_limited.unwrap_err();
        return Ok(
            HttpResponse::NotAcceptable().json(why.to_string())
        );
    };

    if flag{

        // rate limited

        return Ok(
            HttpResponse::NotAcceptable().json("rate limited")
        );

    } else{

        // other api logic
        // ...

        return Ok(
            HttpResponse::Ok().json("json data")
        );

    }

}
```