![Build](https://github.com/jproyo/diesel-sqltype-enum-pg/actions/workflows/build.yml/badge.svg)
![Release](https://github.com/jproyo/diesel-sqltype-enum-pg/actions/workflows/release.yml/badge.svg)
![crates.io](https://img.shields.io/crates/v/diesel_sqltype_enum_pg.svg)

[API Doc](https://docs.rs/diesel_sqltype_enum_pg/0.1.0/diesel-sqltype-enum-pg/)

# Diesel Enum Derivation for `FromSql` and `ToSql`

This procedural macro simplifies the process of generating Diesel `FromSql` and `ToSql` instances for enums with a specific `SqlType`. It is designed for use with Diesel and Postgres, utilizing `ToString` and `FromStr` traits as the base for conversion. This macro generates the necessary boilerplate code for handling enum conversions between Rust and SQL.

## Table of Contents
- [Usage](#usage)
- [Example](#example)
- [Enums and SqlTypes](#enums-and-sqltypes)
- [Dependencies](#dependencies)

---

## Usage

To use this procedural macro, you'll need to add the `enum_diesel_macros` crate to your project's dependencies in `Cargo.toml`. You can then derive the necessary implementations for your enums. Below is an example of how to use the `FromToSql` macro:

```rust
#[derive(Debug, PartialEq, EnumString, Display, FromToSql)]
#[fromtosql(sql_type = MyEntityEnumSqlType)]
enum MyEntityEnum {
    #[strum(serialize = "ONE")]
    EnumOne,
    #[strum(serialize = "TWO")]
    EnumTwo,
}
```

Make sure to import the required dependencies and modules as shown in the example.

## Example
Here's a step-by-step example of how to use the `FromToSql` macro to generate Diesel `FromSql` and `ToSql` instances for your **enum**:

1. Define your custom SQL type using Diesel's `SqlType` and annotate it with diesel attributes:

```rust
pub mod schema {
    pub mod sql_types {
        #[derive(diesel::sql_types::SqlType)]
        #[diesel(postgres_type(name = "myentittyenumsqltype", schema = "myschema"))]
        pub struct MyEntityEnumSqlType;
    }
}
```

2. Import the necessary Diesel and procedural macro dependencies:

```rust
#[derive(Debug, PartialEq, EnumString, Display, FromToSql)]
#[fromtosql(sql_type = MyEntityEnumSqlType)]
enum MyEntityEnum {
    #[strum(serialize = "ONE")]
    EnumOne,
    #[strum(serialize = "TWO")]
    EnumTwo,
}
```

3. Now, you can use your `MyEntityEnum` enum seamlessly with Diesel queries.

## Enums and SqlTypes
The key to using this macro is to ensure that you have a corresponding `SqlType` defined for your **enum**. In this example, `MyEntityEnumSqlType` represents the SQL type for the `MyEntityEnum` **enum**. This `SqlType` is generated in Diesel schemas and serves as the companion **enum** to `MyEntityEnum`.

Ensure that your **enum** also implements either the `FromStr` or `EnumString` trait, which is crucial for parsing the **enum** from SQL values.

## Dependencies
To use this procedural macro, make sure to include the following dependencies in your `Cargo.toml`:

```toml
[dependencies]
diesel = { version = "2.1", features = ["postgres"] }
strum = "0.25"
strum_macros = "0.25"
diesel-sqltype-enum-pg = "0.1.0"
```