Is there an example of implementing NotU8, ValueType, PgHasArrayType for custom enum?

[ycalansy]

I am trying to map Postgres custom_enum[] to Rust Vec<CustomEnum>, but I got various kinds of errors.

I'd like to know if there's an example of how to correctly implement the traits above for custom enums.

Here's the hacky implementation I am currently using:

use sea_query::{with_array::NotU8, Alias, ArrayType, ColumnType, DynIden, Expr, Iden, IntoIden, PostgresQueryBuilder, Query, SeaRc, Value, ValueType, ValueTypeErr};
use sea_query_binder::SqlxBinder;
use sqlx::{
    postgres::{PgHasArrayType, PgTypeInfo},
    PgConnection,
};
use uuid::Uuid;

#[derive(sqlx::Type, Copy, Clone, PartialEq, Eq, Debug)]
#[sqlx(type_name = "test_enum")]
#[sqlx(rename_all = "snake_case")]
pub enum TestEnum {
    First,
    Second,
}

impl PgHasArrayType for TestEnum {
    fn array_type_info() -> PgTypeInfo {
        PgTypeInfo::with_name("_test_enum")
    }
}

impl From<TestEnum> for Value {
    fn from(test_enum: TestEnum) -> Self {
        match test_enum {
            TestEnum::First => "first".into(),
            TestEnum::Second => "second".into(),
        }
    }
}

impl NotU8 for TestEnum {}

impl ValueType for TestEnum {
    fn try_from(v: Value) -> Result<Self, ValueTypeErr> {
        match v {
            Value::String(Some(x)) => match x.as_str() {
                "first" => Ok(TestEnum::First),
                "second" => Ok(TestEnum::Second),
                _ => Err(ValueTypeErr),
            },
            _ => Err(ValueTypeErr),
        }
    }

    fn type_name() -> String {
        "test_enum".to_string()
    }

    fn array_type() -> ArrayType {
        ArrayType::String
    }

    fn column_type() -> ColumnType {
        ColumnType::String(None)
    }
}

#[derive(Iden)]
#[iden(rename = "test_records")]
#[allow(dead_code)]
pub enum TestRecordsSchema {
    Table,
    Id,
    Enums,
}

#[derive(sqlx::FromRow, Debug)]
pub struct TestRecord {
    pub id: Uuid,
    pub enums: Vec<TestEnum>,
}

pub struct TestRecordRepository;

impl TestRecordRepository {
    pub fn new() -> Self {
        Self
    }

    pub async fn get(&self, id: Uuid, conn: &mut PgConnection) -> Result<TestRecord, sqlx::Error> {
        sqlx::query_as("SELECT * FROM test_records WHERE id = $1;")
            .bind(id)
            .fetch_one(&mut *conn)
            .await
    }

    pub async fn create(&self, record: TestRecord, conn: &mut PgConnection) -> Result<TestRecord, sqlx::Error> {
        let (query, args) = Query::insert()
            .into_table(TestRecordsSchema::Table)
            .columns([
                TestRecordsSchema::Id,
                TestRecordsSchema::Enums,
            ])
            .values_panic([
                record.id.into(),
                Expr::value(record.enums).cast_as(Alias::new("test_enum[]")),
            ])
            .returning(Query::returning().expr(Expr::asterisk()))
            .build_sqlx(PostgresQueryBuilder);

        sqlx::query_as_with::<_, TestRecord, _>(&query, args)
            .fetch_one(&mut *conn)
            .await
    }
}