# rst-common
> A shortcut to common Rust crates.
## Motivation
The reason behind this `crate` is due to a lot of common crate libraries that I need to install
for each of my projects and there are a lot of common libraries I've been used to.
So I was just thinking that rather than I'm always
repeat my activities, such as finding the library, register it manually, and so on, I was thinking that it will be nice if I only need
to install a single crate which contains all of my favorite crates.
## Installation
Standard usage :
```toml
[dependencies]
rst-common = {version = "1.2.0"}
```
Example install `with-tokio` feature
```toml
[dependencies]
rst-common = {version = "1.2.0", features: ["with-tokio"]}
```
## Examples
You can look at to `examples` directory to look at how to use this library.
Codes
```ignore
use rst_common::standard::uuid::Uuid;
fn main() {
let uid = Uuid::new_v4();
println!("{}", uid)
}
```
### Special Crates
> **WARNING**
>
> Special crates means, there are spesific ways to use, like `thiserror` and `serde`.
> These crates need a "special" way to use because of their `proc_macro` usages.
---
#### `thiserror`
```ignore
use rst_common::with_errors::thiserror:{self, Error};
#[derive(Error)]
enum MyError {
#[error("general error")]
GeneralError,
}
```
Need to use `self` which give the compiler a signal that the `Error` macro comes from the `thiserror` and the crate exists
#### `serde`
```ignore
use rst_common::standard::serde::{self, Serialize, Deserialize};
#[derive(Debug, Serialize, Deserialize)]
#[serde(crate = "self::serde")]
struct Message {
msg: String,
}
```
Spesific for the `serde` crate, since this crate depends on `serde_derive` which call the `serde::`, we need to explicitly tell the `serde` the used crate path.
## Version Requirements
All of used crates will follow these requirements
- All crates below of `1.x` (`<1.0.0`), will maintain the version until the minor version, example: `~0.1`, which mean, all new updated `patch` version should be automatically updated, but not for `minor` version. The version `~0.1` will automatically update to `0.1.1` and so on, as long as the `minor` version is equal. The reason behind this rule is, any version below of `1.0.0` assumed still under active development, and to maintain compatibility, it will be guarded using it's `minor` version.
- All crates equal or greater than `1.x`, will maintain the version using it's major version, example: `~1`. For example, if we are using a crate that it's version: `1.0.1`, this rule should be updated automatically for the next version of: `1.0.2` or even `1.1.0`, but it will not follow the version `2.0.0` (assumed changed on `major` version will give us breaking compatibility)
> **INFO**
>
> If there are any updated versions to the supported crates, it will be updated manually through this library
For example, now we're support `tokio: ~1`, it means if the `tokio` library release it's new major version: `2.0.0`, this crate will updated manually to support latest versions
## Categories (Feature Flags)
- `standard`
- `full`
- `with-tokio`
- `with-tracing`
- `with-logging`
- `with-errors`
- `with-tests`
- `with-http-tokio`
- `with-cryptography`
This library actually is just re-export all common crates installed based on *features* you chose.
---
### `standard` feature
```rust
#[cfg(feature = "standard")]
pub mod standard {
pub use async_trait;
pub use chrono;
pub use dyn_clone;
pub use erased_serde;
pub use futures;
pub use serde;
pub use serde_json;
pub use uuid;
}
```
### `full` feature
```rust
#[cfg(feature = "full")]
pub mod full {
pub use async_trait;
pub use chrono;
pub use dyn_clone;
pub use erased_serde;
pub use futures;
pub use serde;
pub use serde_json;
pub use uuid;
pub use tokio;
pub use tracing;
pub use tracing_subscriber;
pub use env_logger;
pub use log;
pub use anyhow;
pub use thiserror;
pub use mockall;
pub use table_test;
pub use axum;
pub use hyper;
pub use hyper_util;
pub use tower;
pub use tower_http;
pub use rand;
pub use rand_chacha;
pub use hex;
pub use chacha20poly1305;
pub use blake3;
pub use argon2;
pub use ring;
pub use ed25519_dalek;
pub use x25519_dalek;
}
```
### `with-tokio` feature
```rust
#[cfg(feature = "with-tokio")]
pub mod with_tokio {
pub use tokio;
}
```
### `with-tracing` feature
```rust
#[cfg(feature = "with-tracing")]
pub mod with_tracing {
pub use tracing;
pub use tracing_subscriber;
}
```
### `with-logging` feature
```rust
#[cfg(feature = "with-logging")]
pub mod with_logging {
pub use env_logger;
pub use log;
}
```
### `with-errors` feature
```rust
#[cfg(feature = "with-errors")]
pub mod with_errors {
pub use anyhow;
pub use thiserror;
}
```
### `with-tests` feature
```rust
#[cfg(feature = "with-tests")]
pub mod with_tests {
pub use mockall;
pub use table_test;
}
```
### `with-http-tokio` feature
```rust
#[cfg(feature = "with-http-tokio")]
pub mod with_http_tokio {
pub use axum;
pub use hyper;
pub use hyper_util;
pub use tower;
pub use tower_http;
}
```
### `with-cryptography` feature
```rust
#[cfg(feature = "with-cryptography")]
pub mod with_cryptography {
pub use rand;
pub use rand_chacha;
pub use hex;
pub use chacha20poly1305;
pub use blake3;
pub use argon2;
pub use ring;
pub use sha2;
pub use ed25519_dalek;
pub use x25519_dalek;
}
```