feat: Add generated and generated_always attributes

This commit introduces support for PostgreSQL generated columns by
adding two new field attributes to the `Georm` derive macro:
`#[georm(generated)]` and `#[georm(generated_always)]`.

The `#[georm(generated_always)]` attribute is for fields that are
always generated by the database, such as `GENERATED ALWAYS AS
IDENTITY` columns or columns with a `GENERATED ALWAYS AS (expression)
STORED` clause. These fields are now excluded from `INSERT` and
`UPDATE` statements, preventing accidental writes and ensuring data
integrity at compile time.

The `#[georm(generated)]` attribute is for fields that have a default
value generated by the database but can also be manually overridden,
such as `GENERATED BY DEFAULT AS IDENTITY` columns. These fields
behave similarly to `#[georm(defaultable)]` fields, allowing them to
be omitted from `INSERT` statements to use the database-generated
value.

For now, the behaviour is the same between `#[georm(generated)]` and
`#[georm(defaultable)]`, but the addition of the former now will be
useful for future features.

Key changes:
- Added `generated` and `generated_always` attributes to
  `GeormFieldAttributes`.
- Introduced `GeneratedType` enum in the IR to represent the different
  generation strategies.
- Modified the `create` and `update` query generation to exclude
  fields marked with `#[georm(generated_always)]`.
- Integrated `#[georm(generated)]` fields with the existing
  defaultable struct logic.
- Added validation to prevent conflicting attribute usage, namely
  `#[georm(generated)]` and `#[georm(generated_always)]` on the same
  field.

Implements #3

tests/fixtures/generated.sql

@@ -0,0 +1,8 @@
+INSERT INTO products (name, price, discount_percent)
+VALUES ('Laptop', 999.99, 10);
+
+INSERT INTO products (sku_number, name, price, discount_percent)
+VALUES (5000, 'Mouse', 29.99, 5);
+
+INSERT INTO products (name, price)
+VALUES ('Keyboard', 79.99);

tests/generated.rs

@@ -0,0 +1,64 @@
+use georm::{Defaultable, Georm};
+use sqlx::types::BigDecimal;
+
+mod models;
+use models::{Product, ProductDefault};
+
+#[sqlx::test()]
+async fn create_without_generated_values(pool: sqlx::PgPool) -> sqlx::Result<()> {
+    let base = ProductDefault {
+        name: "Desktop".to_owned(),
+        price: BigDecimal::from(2000),
+        discount_percent: 5,
+        sku_number: None,
+    };
+    let result = base.create(&pool).await?;
+    assert_eq!(BigDecimal::from(1900), result.final_price.unwrap());
+    Ok(())
+}
+
+#[sqlx::test()]
+async fn create_with_manual_generated_value(pool: sqlx::PgPool) -> sqlx::Result<()> {
+    let base = ProductDefault {
+        name: "Monitor".to_owned(),
+        price: BigDecimal::from(750),
+        discount_percent: 10,
+        sku_number: Some(12345),
+    };
+    let result = base.create(&pool).await?;
+    assert_eq!(12345, result.sku_number);
+    assert_eq!("Monitor", result.name);
+    Ok(())
+}
+
+#[sqlx::test(fixtures("generated"))]
+async fn update_does_not_change_generated_always_field(pool: sqlx::PgPool) -> sqlx::Result<()> {
+    let products = Product::find_all(&pool).await?;
+    dbg!(&products);
+    let mut product = products.first().unwrap().clone();
+    let original_final_price = product.clone().final_price;
+    product.name = "Gaming Laptop".to_owned();
+    product.final_price = Some(BigDecimal::from(1000000));
+    dbg!(&product);
+    let updated = product.update(&pool).await?;
+    assert_eq!(original_final_price, updated.final_price);
+    assert_eq!("Gaming Laptop", updated.name);
+    Ok(())
+}
+
+#[sqlx::test(fixtures("generated"))]
+async fn upsert_handles_generated_fields(pool: sqlx::PgPool) -> sqlx::Result<()> {
+    let product = Product::find_by_name("Laptop".to_owned(), &pool).await?;
+    let mut modified_product = product.clone();
+    modified_product.price = BigDecimal::from(1200);
+
+    let upserted = modified_product.create_or_update(&pool).await?;
+
+    // price is updated
+    assert_eq!(upserted.price, BigDecimal::from(1200));
+    // final_price is re-calculated by the DB
+    // 1200 * (1 - 10 / 100.0) = 1080
+    assert_eq!(BigDecimal::from(1080), upserted.final_price.unwrap());
+
+    Ok(())
+}

tests/models.rs

@@ -1,4 +1,5 @@
 use georm::Georm;
+use sqlx::types::BigDecimal;
 
 #[derive(Debug, Georm, PartialEq, Eq, Default)]
 #[georm(
@@ -105,3 +106,26 @@ pub struct UserRole {
     #[georm(defaultable)]
     pub assigned_at: chrono::DateTime<chrono::Utc>,
 }
+
+#[derive(Debug, Georm, PartialEq, Default, Clone)]
+#[georm(table = "products")]
+pub struct Product {
+    #[georm(id, generated_always)]
+    pub id: i32,
+    #[georm(generated)]
+    pub sku_number: i32,
+    pub name: String,
+    pub price: BigDecimal,
+    pub discount_percent: i32,
+    #[georm(generated_always)]
+    pub final_price: Option<BigDecimal>, // Apparently this can be null ?
+}
+
+impl Product {
+    #[allow(dead_code)]
+    pub async fn find_by_name(name: String, pool: &sqlx::PgPool) -> ::sqlx::Result<Self> {
+        ::sqlx::query_as!(Self, "SELECT * FROM products WHERE name = $1", name)
+            .fetch_one(pool)
+            .await
+    }
+}