diesel_derive_composite/

lib.rs

//! Generates boilerplate implementations of `ToSql` and `FromSql` for enums and
//! structs representing PostgreSQL composite types. Works with Diesel 2.3.

use convert_case::{Case, Casing as _};

use darling::util::{Flag, SpannedValue};
use darling::{
	Error, FromAttributes, FromDeriveInput, FromField, FromMeta, FromVariant,
	Result,
};
use darling::ast::Data as AstData;

use proc_macro::TokenStream;

use quote::{format_ident, quote};

use syn::{Attribute, Generics, Ident, Member, Meta, Path, Visibility};

#[derive(Debug, FromDeriveInput)]
#[darling(
	attributes(diesel_composite),
	forward_attrs(diesel),
	supports(enum_unit, struct_named, struct_tuple),
	and_then = Self::validate,
)]
struct Composite {
	vis: Visibility,
	ident: Ident,
	generics: Generics,
	data: AstData<CompositeVariant, CompositeField>,
	rename_all: Option<SpannedValue<Casing>>,
	sql_type: Option<Path>,
	postgres_type: Option<Meta>,
	serialize: Flag,
	deserialize: Flag,
	#[darling(with = Self::parse_diesel_attrs)]
	attrs: Option<Path>,
}

impl Composite {
	fn parse_diesel_attrs(attrs: Vec<Attribute>) -> Result<Option<Path>> {
		#[derive(Debug, FromAttributes)]
		#[darling(attributes(diesel))]
		struct DieselAttrs {
			sql_type: Option<Path>,
		}

		Ok(DieselAttrs::from_attributes(&attrs)?.sql_type)
	}

	fn validate(mut self) -> Result<Self> {
		if self.data.is_struct() && self.rename_all.is_some() {
			return Err(
				Error::custom("rename_all has no effect on structs")
					.with_span(&self.rename_all.unwrap().span())
			)
		}

		if !self.serialize.is_present() && !self.deserialize.is_present() {
			self.serialize = Flag::present();
			self.deserialize = Flag::present();
		}

		if self.sql_type.is_none() {
			self.sql_type = self.attrs.take();

			if self.sql_type.is_none() {
				return Err(Error::custom("missing sql_type"))
			}
		}

		Ok(self)
	}
}

#[derive(Debug, FromVariant)]
#[darling(attributes(diesel_composite))]
struct CompositeVariant {
	ident: Ident,
	rename: Option<String>,
}

#[derive(Debug, Default, FromMeta)]
enum Casing {
	#[darling(rename = "lowercase")]
	Lower,
	#[darling(rename = "UPPERCASE")]
	Upper,
	#[darling(rename = "camelCase")]
	Camel,
	#[darling(rename = "PascalCase")]
	UpperCamel,
	#[default]
	#[darling(rename = "snake_case")]
	Snake,
	#[darling(rename = "SCREAMING_SNAKE_CASE")]
	UpperSnake,
	#[darling(rename = "kebab-case")]
	Kebab,
	#[darling(rename = "SCREAMING-KEBAB-CASE")]
	UpperKebab,
}

impl Casing {
	fn case(self) -> Case<'static> {
		match self {
			Self::Lower => Case::Flat,
			Self::Upper => Case::UpperFlat,
			Self::Camel => Case::Camel,
			Self::UpperCamel => Case::UpperCamel,
			Self::Snake => Case::Snake,
			Self::UpperSnake => Case::UpperSnake,
			Self::Kebab => Case::Kebab,
			Self::UpperKebab => Case::UpperKebab,
		}
	}
}

#[derive(Debug, FromField)]
#[darling(attributes(diesel_composite))]
struct CompositeField {
	ident: Option<Ident>,
	sql_type: Path,
}

/// Macro implementing traits for using a type with database composite types.
///
/// This macro will generate simple boilerplate implementations of the `ToSql`
/// and `FromSql` traits from Diesel.
///
/// When deriving using this macro, you must also derive or otherwise implement
/// [`std::fmt::Debug`]. Additionally, derive `AsExpression` if the type is to
/// be used for serialisation, and/or derive `FromSqlRow` if the type is to be
/// used for deserialisation.
///
/// If referencing a remote stub type (eg. one generated by the Diesel CLI into
/// a "schema.rs" file), set the `sql_type` attribute to the path to this type.
/// Otherwise, to instruct the macro to define a type, specify the database type
/// with the `postgres_type` attribute, and pass a definable identifier as the
/// `sql_type` attribute. The defined type inherits the visibility of the type
/// on which the derive macro is called.
///
/// # Examples
///
/// ## Enum
///
/// Schema:
///
/// ```sql
/// create type my_enum as enum (
/// 	'variantOne',
/// 	'variantTwo',
/// 	'other variant'
/// );
/// ```
///
/// Model:
///
/// ```rs
/// #[derive(Debug, Composite, FromSqlRow, AsExpression)]
/// #[diesel(sql_type = PgMyEnum)]
/// #[diesel_composite(postgres_type(name = "my_enum"), rename_all = "camelCase")]
/// enum MyEnum {
/// 	VariantOne,
/// 	VariantTwo,
/// 	#[diesel_composite(rename = "other variant")]
/// 	Other,
/// }
/// ```
///
/// ## Struct
///
/// Schema:
///
/// ```sql
/// create type my_struct as (
/// 	field_one text,
/// 	field_two integer
/// );
/// ```
///
/// Model:
///
/// ```rs
/// #[derive(Debug, Composite, FromSqlRow, AsExpression)]
/// #[diesel(sql_type = PgMyStruct)]
/// #[diesel_composite(postgres_type(name = "my_struct"))]
/// struct MyStruct {
/// 	#[diesel_composite(sql_type = diesel::sql_types::Text)]
/// 	field_one: String,
/// 	#[diesel_composite(sql_type = diesel::sql_types::Integer)]
/// 	field_two: i32,
/// }
///
/// // or
///
/// #[derive(Debug, Composite, FromSqlRow, AsExpression)]
/// #[diesel(sql_type = PgMyStruct)]
/// #[diesel_composite(postgres_type(name = "my_struct"))]
/// struct MyStruct(
/// 	#[diesel_composite(sql_type = diesel::sql_types::Text)]
/// 	String,
/// 	#[diesel_composite(sql_type = diesel::sql_types::Integer)]
/// 	i32,
/// );
/// ```
///
/// # Attributes
///
/// - **`sql_type`** (required): Specify the path to (or identifier of, if
/// 	`postgres_type` is specified) the mapped type. The macro will recognise
/// 	this field within `#[diesel]` attributes to avoid duplication when
/// 	deriving `AsExpression` too.
/// - **`postgres_type`**: Generate a stub type and specify the PostgreSQL
/// 	identifier. See the Diesel documentation for the `SqlType` macro for
/// 	information about the format of this attribute's content.
/// - **`rename_all`** (enums only): Rename the enum variants according to the
/// 	provided casing specification; valid values are `"lowercase"`,
/// 	`"UPPERCASE"`, `"camelCase"`, `"PascalCase"`, `"snake_case"`,
/// 	`"SCREAMING_SNAKE_CASE"`, `"kebab-case"`, and `"SCREAMING-KEBAB-CASE"`.
/// 	Defaults to `"snake_case"` if omitted.
/// - **`serialize`** and **`deserialize`**: Only generate the `ToSql` or
/// 	`FromSql` implementation respectively. If neither is specified, both
/// 	implementations are generated by default.
///
/// ## On variants
///
/// - **`rename`**: Rename this variant to a specific value.
///
/// ## On fields
///
/// - **`sql_type`** (required): Specify the path to the mapped type for this
/// 	field.
#[proc_macro_derive(Composite, attributes(diesel_composite))]
pub fn derive(input: TokenStream) -> TokenStream {
	let input = syn::parse_macro_input!(input);
	let composite = match Composite::from_derive_input(&input) {
		Ok(composite) => composite,
		Err(err) => return err.write_errors().into(),
	};

	let Composite { vis, ident, sql_type, .. } = composite;

	let mapped_type = composite.postgres_type.map(|postgres_type| quote! {
		#[derive(Clone)]
		#[derive(::diesel::query_builder::QueryId, ::diesel::sql_types::SqlType)]
		#[diesel(#postgres_type)]
		#vis struct #sql_type;
	});

	let (ser_body, de_body) = match composite.data {
		AstData::Enum(variants) => {
			let case = composite.rename_all.unwrap_or_default().into_inner().case();
			let (ser_match_arms, de_match_arms) = variants
				.into_iter()
				.map(|variant| {
					let name = variant.rename
						.unwrap_or_else(|| variant.ident.to_string().to_case(case));
					let ident = variant.ident;

					(
						quote! { Self::#ident => #name },
						quote! { #name => Self::#ident },
					)
				})
				.unzip::<_, _, Vec<_>, Vec<_>>();

			(
				quote! {
					::diesel::serialize::ToSql::<
						::diesel::sql_types::Text,
						::diesel::pg::Pg,
					>
						::to_sql(
							match self {
								#(#ser_match_arms),*
							},
							out,
						)
				},
				quote! {
					<
						::std::string::String as ::diesel::deserialize::FromSql<
							::diesel::sql_types::Text,
							::diesel::pg::Pg,
						>
					>
						::from_sql(bytes)
						.and_then(|string| Ok(match string.as_str() {
							#(#de_match_arms),*,
							_ => return Err("failed to match enum variant".into()),
						}))
				},
			)
		},
		AstData::Struct(fields) => {
			let ((sql_types, field_borrows), (bindings, field_assigns)) = fields
				.into_iter()
				.enumerate()
				.map(|(i, field)| {
					let member = field.ident
						.map(Member::Named)
						.unwrap_or(Member::Unnamed(i.into()));
					let binding = format_ident!("_{i}");

					(
						(
							field.sql_type,
							quote! { &self.#member },
						),
						(
							binding.clone(),
							quote! { #member: #binding },
						),
					)
				})
				.unzip::<_, _, (Vec<_>, Vec<_>), (Vec<_>, Vec<_>)>();

			(
				quote! {
					::diesel::serialize::WriteTuple::<(#(#sql_types),*)>
						::write_tuple(
							&(#(#field_borrows),*),
							out,
						)
				},
				quote! {
					::diesel::deserialize::FromSql::<
						::diesel::sql_types::Record<(#(#sql_types),*)>,
						::diesel::pg::Pg,
					>
						::from_sql(bytes)
						.map(|(#(#bindings),*)| Self {
							#(#field_assigns),*
						})
				},
			)
		},
	};

	let (impl_gens, ty_gens, where_clause) = composite.generics.split_for_impl();

	let ser_impl = composite.serialize.is_present().then(|| quote! {
		impl #impl_gens
			::diesel::serialize::ToSql<#sql_type, ::diesel::pg::Pg> for
			#ident #ty_gens #where_clause
		{
			fn to_sql(
				&self, out: &mut ::diesel::serialize::Output<'_, '_, Pg>,
			) -> ::diesel::serialize::Result {
				#ser_body
			}
		}
	});
	let de_impl = composite.deserialize.is_present().then(|| quote! {
		impl #impl_gens
			::diesel::deserialize::FromSql<#sql_type, ::diesel::pg::Pg> for
			#ident #ty_gens #where_clause
		{
			fn from_sql(
				bytes: ::diesel::pg::PgValue<'_>,
			) -> ::diesel::deserialize::Result<Self> {
				#de_body
			}
		}
	});

	quote! {
		#mapped_type
		#ser_impl
		#de_impl
	}.into()
}