Add derive DataObject (#421)

Author: jayvdb

.mise.toml

@@ -1,8 +1,9 @@
 [tools]
+"cargo:cargo-expand" = "latest"
+"cargo:pep257" = "latest"
+"cargo:timeout-cli" = "latest"
 editorconfig-checker = "latest"
 ephemeral-postgres = "latest"
 osv-scanner = "latest"
 rust = "stable"
-"cargo:pep257" = "latest"
-"cargo:timeout-cli" = "latest"
 typos = "latest"

README.md

@@ -43,6 +43,24 @@ struct Post {
 }
 ```
 
+Alternatively, you can use the `#[derive(DataObject)]` syntax:
+
+``` rust
+#[derive(DataObject, Default)]
+struct Post {
+    id: AutoPk<i32>,
+    title: String,
+    body: String,
+    published: bool,
+    likes: i32,
+    tags: Many<Tag>,
+    blog: ForeignKey<Blog>,
+    byline: Option<String>,
+}
+```
+
+Both syntaxes are functionally equivalent.
+
 An _object_ is an instance of a _model_. An object is created like a
 normal struct instance, but must be saved in order to be persisted.
 

butane/src/lib.rs

@@ -6,7 +6,7 @@
 
 #![deny(missing_docs)]
 
-pub use butane_codegen::{butane_type, dataresult, model, FieldType, PrimaryKeyType};
+pub use butane_codegen::{butane_type, dataresult, model, DataObject, FieldType, PrimaryKeyType};
 #[cfg(feature = "pg")]
 pub use butane_core::custom;
 pub use butane_core::fkey::{ForeignKey, ForeignKeyOpsSync};

butane/tests/derive_model.rs

@@ -0,0 +1,74 @@
+//! Test that #[derive(DataObject)] works the same as #[model]
+
+use butane::db::ConnectionAsync;
+use butane::{query, AutoPk, DataObject};
+use butane_test_helper::*;
+use butane_test_macros::butane_test;
+
+// Test basic derive(DataObject) usage
+#[derive(DataObject, Debug, Clone, PartialEq)]
+struct ProductDataObject {
+    id: AutoPk<i64>,
+    name: String,
+    price: i32,
+}
+
+impl ProductDataObject {
+    fn new(name: String, price: i32) -> Self {
+        ProductDataObject {
+            id: AutoPk::default(),
+            name,
+            price,
+        }
+    }
+}
+
+// Test derive(DataObject) with custom table name and pk
+#[derive(DataObject, Debug, PartialEq)]
+#[table = "items"]
+struct ItemDataObject {
+    #[pk]
+    sku: String,
+    description: String,
+}
+
+#[butane_test]
+async fn basic_derive(conn: ConnectionAsync) {
+    let mut product = ProductDataObject::new("Widget".to_string(), 100);
+    product.save(&conn).await.unwrap();
+
+    let loaded = ProductDataObject::get(&conn, product.id).await.unwrap();
+    assert_eq!(product, loaded);
+    assert_eq!(loaded.name, "Widget");
+    assert_eq!(loaded.price, 100);
+}
+
+#[butane_test]
+async fn derive_with_custom_table(conn: ConnectionAsync) {
+    let mut item = ItemDataObject {
+        sku: "ABC123".to_string(),
+        description: "Test item".to_string(),
+    };
+    item.save(&conn).await.unwrap();
+
+    let loaded = ItemDataObject::get(&conn, "ABC123".to_string())
+        .await
+        .unwrap();
+    assert_eq!(item, loaded);
+    assert_eq!(loaded.description, "Test item");
+}
+
+#[butane_test]
+async fn derive_query(conn: ConnectionAsync) {
+    let mut p1 = ProductDataObject::new("Cheap".to_string(), 50);
+    let mut p2 = ProductDataObject::new("Expensive".to_string(), 200);
+    p1.save(&conn).await.unwrap();
+    p2.save(&conn).await.unwrap();
+
+    let results = query!(ProductDataObject, price < 100)
+        .load(&conn)
+        .await
+        .unwrap();
+    assert_eq!(results.len(), 1);
+    assert_eq!(results[0].name, "Cheap");
+}

butane_codegen/src/lib.rs

@@ -59,6 +59,47 @@ pub fn model(_args: TokenStream, input: TokenStream) -> TokenStream {
     codegen::model_with_migrations(input.into(), &mut migrations_for_dir()).into()
 }
 
+/// Derive macro which marks a struct as being a data model.
+///
+/// It generates an implementation of [`DataObject`](butane_core::DataObject).
+///
+/// This is functionally equivalent to the `#[model]` attribute macro and can be
+/// used interchangeably. Use `#[derive(DataObject)]` when you prefer the derive syntax
+/// or are already using other derive macros on your struct.
+///
+/// ## Restrictions on model types:
+/// 1. The type of each field must implement [`FieldType`] or be [`Many`].
+/// 2. There must be a primary key field. This must be either annotated with a `#[pk]` attribute or named `id`.
+///
+/// ## Helper Attributes
+/// * `#[table = "NAME"]` used on the struct to specify the name of the table (defaults to struct name)
+/// * `#[pk]` on a field to specify that it is the primary key.
+/// * `#[unique]` on a field indicates that the field's value must be unique
+///   (perhaps implemented as the SQL UNIQUE constraint by some backends).
+/// * `#[default]` should be used on fields added by later migrations to avoid errors on existing objects.
+///   Unnecessary if the new field is an `Option<>`
+///
+/// For example
+/// ```ignore
+/// #[derive(DataObject, Debug)]
+/// #[table = "posts"]
+/// pub struct Post {
+///   #[pk] // unnecessary if identifier were named id instead
+///   pub identifier: AutoPk<i32>,
+///   pub title: String,
+///   pub content: String,
+///   #[default = false]
+///   pub published: bool,
+/// }
+/// ```
+///
+/// [`FieldType`]: crate::FieldType
+/// [`Many`]: butane_core::many::Many
+#[proc_macro_derive(DataObject, attributes(table, pk, unique, default, auto))]
+pub fn derive_data_object(input: TokenStream) -> TokenStream {
+    codegen::derive_dataobject_with_migrations(input.into(), &mut migrations_for_dir()).into()
+}
+
 /// Attribute macro which generates an implementation of
 /// [`DataResult`](butane_core::DataResult). Continuing with our blog
 /// post example from [model](macro@model), we could create a `DataResult` with

butane_core/src/codegen/mod.rs

@@ -82,7 +82,35 @@ static PATH_MAPPINGS: Map<&'static str, &'static str> = phf_map! {
 const PATH_RESOLVER: PathResolver<&'static Map<&'static str, &'static str>> =
     create_static_resolver(&PATH_MAPPINGS, true);
 
-/// Implementation of `#[butane::model]`.
+/// Core implementation shared by both `#[model]` attribute macro and `#[derive(DataObject)]` derive macro.
+///
+/// Generates the `DataObject` trait implementation and field expression helpers.
+/// Also writes migration information to disk.
+///
+/// Returns a tuple of (trait implementations, field expressions).
+fn dataobject_impl<M>(
+    ast_struct: &ItemStruct,
+    ms: &mut impl MigrationsMut<M = M>,
+) -> (TokenStream2, TokenStream2)
+where
+    M: MigrationMut,
+{
+    let config: dbobj::Config = config_from_attributes(ast_struct);
+    migration::write_table_to_disk(ms, ast_struct, &config).unwrap();
+    let impltraits = dbobj::impl_dbobject(ast_struct, &config);
+    let fieldexprs = dbobj::add_fieldexprs(ast_struct, &config);
+    (impltraits, fieldexprs)
+}
+
+/// Implementation of the `#[model]` attribute macro.
+///
+/// This attribute macro transforms a struct into a database model by:
+/// 1. Generating `DataObject` trait implementations
+/// 2. Generating field expression helpers
+/// 3. Recording migration information
+/// 4. Re-emitting the struct definition with helper attributes removed
+///
+/// The macro accepts helper attributes like `#[table]`, `#[pk]`, `#[unique]`, etc.
 pub fn model_with_migrations<M>(
     input: TokenStream2,
     ms: &mut impl MigrationsMut<M = M>,
@@ -94,17 +122,12 @@ where
     // attributes but proc macro attributes can't yet (nor can they
     // create field attributes)
     let mut ast_struct: ItemStruct = syn::parse2(input).unwrap();
-    let config: dbobj::Config = config_from_attributes(&ast_struct);
 
     // Filter out our helper attributes
     let attrs: Vec<Attribute> = filter_helper_attributes(&ast_struct);
-
     let vis = &ast_struct.vis;
 
-    migration::write_table_to_disk(ms, &ast_struct, &config).unwrap();
-
-    let impltraits = dbobj::impl_dbobject(&ast_struct, &config);
-    let fieldexprs = dbobj::add_fieldexprs(&ast_struct, &config);
+    let (impltraits, fieldexprs) = dataobject_impl(&ast_struct, ms);
 
     let fields: Punctuated<Field, syn::token::Comma> =
         match remove_helper_field_attributes(&mut ast_struct.fields) {
@@ -124,6 +147,31 @@ where
     )
 }
 
+/// Implementation of the `#[derive(DataObject)]` derive macro.
+///
+/// This derive macro generates the same `DataObject` trait implementations and helpers
+/// as the `#[model]` attribute macro, but follows derive macro conventions:
+/// - Only generates additional code (trait impls, helpers)
+/// - Does NOT re-emit the struct definition
+/// - Requires the struct to already exist with all fields defined
+///
+/// Functionally equivalent to `#[model]` but with derive syntax.
+pub fn derive_dataobject_with_migrations<M>(
+    input: TokenStream2,
+    ms: &mut impl MigrationsMut<M = M>,
+) -> TokenStream2
+where
+    M: MigrationMut,
+{
+    let ast_struct: ItemStruct = syn::parse2(input).unwrap();
+    let (impltraits, fieldexprs) = dataobject_impl(&ast_struct, ms);
+
+    quote!(
+        #impltraits
+        #fieldexprs
+    )
+}
+
 /// Implementation of `#[butane::dataresult(<Model>)]`.
 pub fn dataresult(args: TokenStream2, input: TokenStream2) -> TokenStream2 {
     let dbo: Ident = syn::parse2(args)