toasty_driver_integration_suite/tests/

embed_struct.rs

use toasty::schema::{
    app::FieldTy,
    mapping::{self, FieldPrimitive, FieldStruct},
};
use toasty_core::stmt;
use uuid::Uuid;

use crate::prelude::*;

/// Tests that embedded structs are registered in the app schema but don't create
/// their own database tables (they're inlined into parent models).
#[driver_test(scenario(crate::scenarios::user_with_address))]
pub async fn basic_embedded_struct(test: &mut Test) {
    let db = setup(test).await;
    let schema = db.schema();

    // Embedded models exist in app schema as Model::EmbeddedStruct
    let address = &schema.app.models[&Address::id()];
    assert_struct!(address, toasty::schema::app::Model::EmbeddedStruct({
        name.upper_camel_case(): "Address",
        fields: [
            { name.app: Some("street") },
            { name.app: Some("city") },
        ],
    }));
}

/// Tests the complete schema generation and mapping for embedded fields:
/// - App schema: embedded field with correct type reference
/// - DB schema: embedded fields flattened to columns (address_street, address_city)
/// - Mapping: projection expressions for field lowering/lifting
#[driver_test(scenario(crate::scenarios::user_with_address))]
pub async fn root_model_with_embedded_field(test: &mut Test) {
    let db = setup(test).await;
    let schema = db.schema();

    // Both embedded and root models exist in app schema
    assert_struct!(schema.app.models, #{
        Address::id(): toasty::schema::app::Model::EmbeddedStruct({
            name.upper_camel_case(): "Address",
            fields: [
                { name.app: Some("street") },
                { name.app: Some("city") },
            ],
        }),
        User::id(): toasty::schema::app::Model::Root({
            name.upper_camel_case(): "User",
            fields: [
                { name.app: Some("id") },
                {
                    name.app: Some("address"),
                    ty: FieldTy::Embedded({
                        target: == Address::id(),
                    }),
                },
            ],
        }),
    });

    // Database table has flattened columns with prefix (address_street, address_city)
    // This is the key transformation: embedded struct fields become individual columns
    assert_struct!(schema.db.tables, [
        {
            name: =~ r"users$",
            columns: [
                { name: "id" },
                { name: "address_street" },
                { name: "address_city" },
            ],
        },
    ]);

    let user = &schema.app.models[&User::id()];
    let user_table = schema.table_for(user);
    let user_mapping = &schema.mapping.models[&User::id()];

    // Mapping contains projection expressions that extract embedded fields
    // Model -> Table (lowering): project(address_field, [0]) extracts street
    // This allows queries like User.address.city to become address_city column refs
    assert_struct!(user_mapping, {
        columns.len(): 3,
        fields: [
            mapping::Field::Primitive(FieldPrimitive {
                column: == user_table.columns[0].id,
                lowering: 0,
                ..
            }),
            mapping::Field::Struct(FieldStruct {
                fields: [
                    mapping::Field::Primitive(FieldPrimitive {
                        column: == user_table.columns[1].id,
                        lowering: 1,
                        ..
                    }),
                    mapping::Field::Primitive(FieldPrimitive {
                        column: == user_table.columns[2].id,
                        lowering: 2,
                        ..
                    }),
                ],
                ..
            }),
        ],
        model_to_table.fields: [
            _,
            == stmt::Expr::project(
                stmt::Expr::ref_self_field(user.as_root_unwrap().fields[1].id),
                [0],
            ),
            == stmt::Expr::project(
                stmt::Expr::ref_self_field(user.as_root_unwrap().fields[1].id),
                [1],
            ),
        ],
    });

    // Table -> Model (lifting): columns are grouped back into record
    // [id_col, street_col, city_col] -> [id, record([street_col, city_col])]
    let table_to_model = user_mapping
        .table_to_model
        .lower_returning_model()
        .into_record();

    assert_struct!(
        table_to_model.fields,
        [
            _,
            stmt::Expr::Record(stmt::ExprRecord {
                fields: [
                    == stmt::Expr::column(user_table.columns[1].id),
                    == stmt::Expr::column(user_table.columns[2].id),
                ],
            }),
        ]
    );
}

/// Tests basic CRUD operations with embedded fields across all ID types.
/// Validates create, read, update (both instance and query-based), and delete.
#[driver_test]
pub async fn create_and_query_embedded(t: &mut Test) -> Result<()> {
    #[derive(Debug, toasty::Embed)]
    struct Address {
        street: String,
        city: String,
    }

    #[derive(Debug, toasty::Model)]
    struct User {
        #[key]
        #[auto]
        id: uuid::Uuid,
        name: String,
        address: Address,
    }

    let mut db = t.setup_db(models!(User)).await;

    let mut user = User::create()
        .name("Alice")
        .address(Address {
            street: "123 Main St".to_string(),
            city: "Springfield".to_string(),
        })
        .exec(&mut db)
        .await?;

    // Read: embedded struct is reconstructed from flattened columns
    let found = User::get_by_id(&mut db, &user.id).await?;
    assert_eq!(found.address.street, "123 Main St");
    assert_eq!(found.address.city, "Springfield");

    // Update (instance): entire embedded struct can be replaced
    user.update()
        .address(Address {
            street: "456 Oak Ave".to_string(),
            city: "Shelbyville".to_string(),
        })
        .exec(&mut db)
        .await?;

    let found = User::get_by_id(&mut db, &user.id).await?;
    assert_eq!(found.address.street, "456 Oak Ave");

    // Update (query-based): tests query builder with embedded fields
    User::filter_by_id(user.id)
        .update()
        .address(Address {
            street: "789 Pine Rd".to_string(),
            city: "Capital City".to_string(),
        })
        .exec(&mut db)
        .await?;

    let found = User::get_by_id(&mut db, &user.id).await?;
    assert_eq!(found.address.street, "789 Pine Rd");

    // Delete: cleanup
    let id = user.id;
    user.delete().exec(&mut db).await?;
    assert_err!(User::get_by_id(&mut db, &id).await);
    Ok(())
}

/// Tests code generation for embedded struct field accessors:
/// - User::fields().address() returns AddressFields
/// - Chaining works: User::fields().address().city()
/// - Both model and embedded struct have fields() methods
/// This is purely a compile-time test validating the generated API.
#[driver_test(scenario(crate::scenarios::user_with_zip_address))]
pub async fn embedded_struct_fields_codegen(test: &mut Test) {
    let _db = setup(test).await;

    // Direct chaining: User::fields().address().city()
    let _city_path = User::fields().address().city();

    // Intermediate variable: AddressFields can be stored and reused
    let address_fields = User::fields().address();
    let _city_path_2 = address_fields.city();

    // Embedded struct has its own fields() method
    let _address_city = Address::fields().city();

    // Paths are usable in filter expressions (compile-time type check)
    let _query = User::all().filter(User::fields().address().city().eq("Seattle"));
}

/// Tests querying by embedded struct fields with composite keys (DynamoDB compatible).
/// Validates:
/// - Equality queries on embedded fields work across all databases
/// - Different embedded fields (city, zip) can be queried
/// - Multiple partition keys work correctly
/// - Results are properly filtered and returned
#[driver_test]
pub async fn query_embedded_struct_fields(t: &mut Test) -> Result<()> {
    #[derive(Debug, toasty::Embed)]
    struct Address {
        street: String,
        city: String,
        zip: String,
    }

    #[derive(Debug, toasty::Model)]
    #[key(partition = country, local = id)]
    #[allow(dead_code)]
    struct User {
        #[auto]
        id: uuid::Uuid,
        country: String,
        name: String,
        address: Address,
    }

    let mut db = t.setup_db(models!(User)).await;

    // Create users in different countries and cities
    let users_data = [
        ("USA", "Alice", "123 Main St", "Seattle", "98101"),
        ("USA", "Bob", "456 Oak Ave", "Seattle", "98102"),
        ("USA", "Charlie", "789 Pine Rd", "Portland", "97201"),
        ("USA", "Diana", "321 Elm St", "Portland", "97202"),
        ("CAN", "Eve", "111 Maple Dr", "Vancouver", "V6B 1A1"),
        ("CAN", "Frank", "222 Cedar Ln", "Vancouver", "V6B 2B2"),
        ("CAN", "Grace", "333 Birch Way", "Toronto", "M5H 1A1"),
    ];

    for (country, name, street, city, zip) in users_data {
        User::create()
            .country(country)
            .name(name)
            .address(Address {
                street: street.to_string(),
                city: city.to_string(),
                zip: zip.to_string(),
            })
            .exec(&mut db)
            .await?;
    }

    // Verification: all 7 users were created (DynamoDB requires partition key in queries)
    let mut all_users = Vec::new();
    for country in ["USA", "CAN"] {
        let mut users = User::filter(User::fields().country().eq(country))
            .exec(&mut db)
            .await?;
        all_users.append(&mut users);
    }
    assert_eq!(all_users.len(), 7);

    // Core test: query by partition key + embedded field
    // This tests the projection simplification: address.city -> address_city column
    let seattle_users = User::filter(
        User::fields()
            .country()
            .eq("USA")
            .and(User::fields().address().city().eq("Seattle")),
    )
    .exec(&mut db)
    .await?;

    assert_eq!(seattle_users.len(), 2);
    let mut names: Vec<_> = seattle_users.iter().map(|u| u.name.as_str()).collect();
    names.sort();
    assert_eq!(names, ["Alice", "Bob"]);

    // Validate different partition key (CAN) works
    let vancouver_users = User::filter(
        User::fields()
            .country()
            .eq("CAN")
            .and(User::fields().address().city().eq("Vancouver")),
    )
    .exec(&mut db)
    .await?;

    assert_eq!(vancouver_users.len(), 2);

    // Validate different embedded field (zip instead of city) works
    let user_98101 = User::filter(
        User::fields()
            .country()
            .eq("USA")
            .and(User::fields().address().zip().eq("98101")),
    )
    .exec(&mut db)
    .await?;

    assert_eq!(user_98101.len(), 1);
    assert_eq!(user_98101[0].name, "Alice");
    Ok(())
}

/// Tests comparison operators (gt, lt, ge, le, ne) on embedded struct fields.
/// SQL-only: DynamoDB doesn't support range queries on non-key attributes.
/// Validates that all comparison operators work correctly with embedded fields.
#[driver_test(requires(scan))]
pub async fn query_embedded_fields_comparison_ops(t: &mut Test) -> Result<()> {
    #[derive(Debug, toasty::Embed)]
    struct Stats {
        score: i64,
        rank: i64,
    }

    #[derive(Debug, toasty::Model)]
    #[allow(dead_code)]
    struct Player {
        #[key]
        #[auto]
        id: uuid::Uuid,
        name: String,
        stats: Stats,
    }

    let mut db = t.setup_db(models!(Player)).await;

    for (name, score, rank) in [
        ("Alice", 100, 1),
        ("Bob", 85, 2),
        ("Charlie", 70, 3),
        ("Diana", 55, 4),
        ("Eve", 40, 5),
    ] {
        Player::create()
            .name(name)
            .stats(Stats { score, rank })
            .exec(&mut db)
            .await?;
    }

    // Test gt: score > 80 should return Alice (100) and Bob (85)
    let high_scorers = Player::filter(Player::fields().stats().score().gt(80))
        .exec(&mut db)
        .await?;
    assert_eq!(high_scorers.len(), 2);

    // Test le: score <= 55 should return Diana (55) and Eve (40)
    let low_scorers = Player::filter(Player::fields().stats().score().le(55))
        .exec(&mut db)
        .await?;
    assert_eq!(low_scorers.len(), 2);

    // Test ne: score != 70 excludes only Charlie
    let not_charlie = Player::filter(Player::fields().stats().score().ne(70))
        .exec(&mut db)
        .await?;
    assert_eq!(not_charlie.len(), 4);

    // Test ge: score >= 70 should return Alice, Bob, Charlie
    let mid_to_high = Player::filter(Player::fields().stats().score().ge(70))
        .exec(&mut db)
        .await?;
    assert_eq!(mid_to_high.len(), 3);
    Ok(())
}

/// Tests `eq` and `ne` on a whole multi-field embedded value: both
/// decompose into per-column comparisons — equality into AND, inequality
/// into OR — so `ne` matches rows differing in any column.
#[driver_test(requires(scan))]
pub async fn whole_embedded_struct_eq_ne(t: &mut Test) -> Result<()> {
    #[derive(Debug, toasty::Embed)]
    struct Point {
        x: i64,
        y: i64,
    }

    #[derive(Debug, toasty::Model)]
    struct Pin {
        #[key]
        #[auto]
        id: uuid::Uuid,
        label: String,
        location: Point,
    }

    let mut db = t.setup_db(models!(Pin)).await;

    for (label, x, y) in [("a", 1, 1), ("b", 1, 2), ("c", 2, 1)] {
        toasty::create!(Pin {
            label,
            location: Point { x, y },
        })
        .exec(&mut db)
        .await?;
    }

    let hits = Pin::filter(Pin::fields().location().eq(Point { x: 1, y: 2 }))
        .exec(&mut db)
        .await?;
    assert_eq!(hits.len(), 1);
    assert_eq!(hits[0].label, "b");

    let hits = Pin::filter(Pin::fields().location().ne(Point { x: 1, y: 2 }))
        .exec(&mut db)
        .await?;
    let mut labels: Vec<_> = hits.iter().map(|p| p.label.as_str()).collect();
    labels.sort();
    assert_eq!(labels, ["a", "c"]);

    Ok(())
}

/// Tests querying by multiple embedded fields in a single query (AND conditions).
/// SQL-only: DynamoDB requires partition key in queries.
/// Validates that complex filters with multiple embedded fields work correctly.
#[driver_test(requires(scan))]
pub async fn query_embedded_multiple_fields(t: &mut Test) -> Result<()> {
    #[derive(Debug, toasty::Embed)]
    struct Coordinates {
        x: i64,
        y: i64,
        z: i64,
    }

    #[derive(Debug, toasty::Model)]
    #[allow(dead_code)]
    struct Location {
        #[key]
        #[auto]
        id: uuid::Uuid,
        name: String,
        coords: Coordinates,
    }

    let mut db = t.setup_db(models!(Location)).await;

    for (name, x, y, z) in [
        ("Origin", 0, 0, 0),
        ("Point A", 10, 20, 0),
        ("Point B", 10, 30, 0),
        ("Point C", 10, 20, 5),
        ("Point D", 20, 20, 0),
    ] {
        Location::create()
            .name(name)
            .coords(Coordinates { x, y, z })
            .exec(&mut db)
            .await?;
    }

    // Test 2-field AND: x=10 AND y=20 matches Point A (10,20,0) and Point C (10,20,5)
    let matching = Location::filter(
        Location::fields()
            .coords()
            .x()
            .eq(10)
            .and(Location::fields().coords().y().eq(20)),
    )
    .exec(&mut db)
    .await?;

    assert_eq!(matching.len(), 2);
    let mut names: Vec<_> = matching.iter().map(|l| l.name.as_str()).collect();
    names.sort();
    assert_eq!(names, ["Point A", "Point C"]);

    // Test 3-field AND: adding z=0 narrows to just Point A
    // Validates chaining multiple embedded field conditions
    let exact_match = Location::filter(
        Location::fields()
            .coords()
            .x()
            .eq(10)
            .and(Location::fields().coords().y().eq(20))
            .and(Location::fields().coords().z().eq(0)),
    )
    .exec(&mut db)
    .await?;

    assert_eq!(exact_match.len(), 1);
    assert_eq!(exact_match[0].name, "Point A");
    Ok(())
}

/// Tests UPDATE operations filtered by embedded struct fields.
/// SQL-only: DynamoDB requires partition key in queries/updates.
/// Validates that updates can target rows based on embedded field values.
#[driver_test(requires(sql))]
pub async fn update_with_embedded_field_filter(t: &mut Test) -> Result<()> {
    #[derive(Debug, toasty::Embed)]
    struct Metadata {
        version: i64,
        status: String,
    }

    #[derive(Debug, toasty::Model)]
    #[allow(dead_code)]
    struct Document {
        #[key]
        #[auto]
        id: uuid::Uuid,
        title: String,
        meta: Metadata,
    }

    let mut db = t.setup_db(models!(Document)).await;

    // Setup: Doc A (v1, draft), Doc B (v2, draft), Doc C (v1, published)
    for (title, version, status) in [
        ("Doc A", 1, "draft"),
        ("Doc B", 2, "draft"),
        ("Doc C", 1, "published"),
    ] {
        Document::create()
            .title(title)
            .meta(Metadata {
                version,
                status: status.to_string(),
            })
            .exec(&mut db)
            .await?;
    }

    // Update documents where status="draft" AND version=1 (should only match Doc A)
    // Tests that embedded field filters work in UPDATE statements
    Document::filter(
        Document::fields()
            .meta()
            .status()
            .eq("draft")
            .and(Document::fields().meta().version().eq(1)),
    )
    .update()
    .meta(Metadata {
        version: 2,
        status: "draft".to_string(),
    })
    .exec(&mut db)
    .await?;

    // Doc A should be updated (was v1 draft, now v2 draft)
    let doc_a = Document::filter(Document::fields().title().eq("Doc A"))
        .exec(&mut db)
        .await?;
    assert_eq!(doc_a[0].meta.version, 2);

    // Doc B should be unchanged (was v2 draft, still v2 draft)
    let doc_b = Document::filter(Document::fields().title().eq("Doc B"))
        .exec(&mut db)
        .await?;
    assert_eq!(doc_b[0].meta.version, 2);

    // Doc C should be unchanged (was v1 published, still v1 published - wrong status)
    let doc_c = Document::filter(Document::fields().title().eq("Doc C"))
        .exec(&mut db)
        .await?;
    assert_eq!(doc_c[0].meta.version, 1);
    Ok(())
}

/// Tests partial updates of embedded struct fields via `stmt::patch` /
/// `stmt::apply`. This validates that individual fields within an embedded
/// struct can be updated without replacing the entire struct.
#[driver_test(scenario(crate::scenarios::user_with_zip_address))]
pub async fn partial_update_embedded_fields(t: &mut Test) -> Result<()> {
    let mut db = setup(t).await;

    // Create a user with initial address
    let mut user = User::create()
        .name("Alice")
        .address(Address {
            street: "123 Main St".to_string(),
            city: "Boston".to_string(),
            zip: "02101".to_string(),
        })
        .exec(&mut db)
        .await?;

    // Verify initial state
    assert_struct!(user.address, {
        street: "123 Main St",
        city: "Boston",
        zip: "02101",
    });

    // Partial update: only change city, leave street and zip unchanged
    user.update()
        .address(toasty::stmt::patch(Address::fields().city(), "Seattle"))
        .exec(&mut db)
        .await?;

    // Verify only city was updated
    assert_struct!(user.address, {
        street: "123 Main St",
        city: "Seattle",
        zip: "02101",
    });

    // Verify the update persisted to database
    let found = User::get_by_id(&mut db, &user.id).await?;
    assert_struct!(found.address, {
        street: "123 Main St",
        city: "Seattle",
        zip: "02101",
    });

    // Multiple field update in one call
    user.update()
        .address(toasty::stmt::apply([
            toasty::stmt::patch(Address::fields().city(), "Portland"),
            toasty::stmt::patch(Address::fields().zip(), "97201"),
        ]))
        .exec(&mut db)
        .await?;

    // Verify both fields were updated, street unchanged
    assert_struct!(user.address, {
        street: "123 Main St",
        city: "Portland",
        zip: "97201",
    });

    // Verify the update persisted
    let found = User::get_by_id(&mut db, &user.id).await?;
    assert_struct!(found.address, {
        street: "123 Main St",
        city: "Portland",
        zip: "97201",
    });

    // Multiple calls to the address setter should accumulate
    user.update()
        .address(toasty::stmt::patch(
            Address::fields().street(),
            "456 Oak Ave",
        ))
        .address(toasty::stmt::patch(Address::fields().zip(), "97202"))
        .exec(&mut db)
        .await?;

    // Verify all updates applied in memory
    assert_struct!(user.address, {
        street: "456 Oak Ave",
        city: "Portland",
        zip: "97202",
    });

    // Verify both accumulated assignments persisted to the database
    let found = User::get_by_id(&mut db, &user.id).await?;
    assert_struct!(found.address, {
        street: "456 Oak Ave",
        city: "Portland",
        zip: "97202",
    });
    Ok(())
}

/// Tests deeply nested embedded types (3+ levels) to verify schema building
/// handles arbitrary nesting depth correctly.
/// Validates:
/// - App schema: all embedded models registered
/// - DB schema: deeply nested fields flattened with proper prefixes
/// - Mapping: nested Field::Struct structure with correct columns maps
/// - model_to_table: nested projection expressions
#[driver_test]
pub async fn deeply_nested_embedded_schema(test: &mut Test) {
    // 3 levels of nesting: Location -> City -> Address -> User
    #[derive(toasty::Embed)]
    struct Location {
        lat: i64,
        lon: i64,
    }

    #[derive(toasty::Embed)]
    struct City {
        name: String,
        location: Location,
    }

    #[derive(toasty::Embed)]
    struct Address {
        street: String,
        city: City,
    }

    #[derive(toasty::Model)]
    struct User {
        #[key]
        id: String,
        #[allow(dead_code)]
        address: Address,
    }

    let db = test.setup_db(models!(User)).await;
    let schema = db.schema();

    // All embedded models should exist in app schema
    assert_struct!(schema.app.models, #{
        Location::id(): toasty::schema::app::Model::EmbeddedStruct({
            name.upper_camel_case(): "Location",
            fields.len(): 2,
        }),
        City::id(): toasty::schema::app::Model::EmbeddedStruct({
            name.upper_camel_case(): "City",
            fields: [
                { name.app: Some("name") },
                {
                    name.app: Some("location"),
                    ty: FieldTy::Embedded({
                        target: == Location::id(),
                    }),
                },
            ],
        }),
        Address::id(): toasty::schema::app::Model::EmbeddedStruct({
            name.upper_camel_case(): "Address",
            fields: [
                { name.app: Some("street") },
                {
                    name.app: Some("city"),
                    ty: FieldTy::Embedded({
                        target: == City::id(),
                    }),
                },
            ],
        }),
        User::id(): toasty::schema::app::Model::Root({
            name.upper_camel_case(): "User",
            fields: [
                { name.app: Some("id") },
                {
                    name.app: Some("address"),
                    ty: FieldTy::Embedded({
                        target: == Address::id(),
                    }),
                },
            ],
        }),
    });

    // Database table should flatten all nested fields with proper prefixes
    // Expected columns:
    // - id
    // - address_street
    // - address_city_name
    // - address_city_location_lat
    // - address_city_location_lon
    assert_struct!(schema.db.tables, [
        {
            name: =~ r"users$",
            columns: [
                { name: "id" },
                { name: "address_street" },
                { name: "address_city_name" },
                { name: "address_city_location_lat" },
                { name: "address_city_location_lon" },
            ],
        },
    ]);

    let user = &schema.app.models[&User::id()];
    let user_table = schema.table_for(user);
    let user_mapping = &schema.mapping.models[&User::id()];

    // Mapping should have nested Field::Struct structure
    // User.fields[1] (address) -> FieldStruct {
    //   fields[0] (street) -> FieldPrimitive { column: address_street }
    //   fields[1] (city) -> FieldStruct {
    //     fields[0] (name) -> FieldPrimitive { column: address_city_name }
    //     fields[1] (location) -> FieldStruct {
    //       fields[0] (lat) -> FieldPrimitive { column: address_city_location_lat }
    //       fields[1] (lon) -> FieldPrimitive { column: address_city_location_lon }
    //     }
    //   }
    // }

    assert_eq!(
        user_mapping.fields.len(),
        2,
        "User should have 2 fields: id and address"
    );

    // Check address field (index 1)
    let address_field = user_mapping.fields[1]
        .as_struct()
        .expect("User.address should be Field::Struct");

    assert_eq!(
        address_field.fields.len(),
        2,
        "Address should have 2 fields: street and city"
    );

    // Check address.street (index 0)
    let street_field = address_field.fields[0]
        .as_primitive()
        .expect("Address.street should be Field::Primitive");
    assert_eq!(
        street_field.column, user_table.columns[1].id,
        "street should map to address_street column"
    );

    // Check address.city (index 1)
    let city_field = address_field.fields[1]
        .as_struct()
        .expect("Address.city should be Field::Struct");

    assert_eq!(
        city_field.fields.len(),
        2,
        "City should have 2 fields: name and location"
    );

    // Check address.city.name (index 0)
    let city_name_field = city_field.fields[0]
        .as_primitive()
        .expect("City.name should be Field::Primitive");
    assert_eq!(
        city_name_field.column, user_table.columns[2].id,
        "city.name should map to address_city_name column"
    );

    // Check address.city.location (index 1)
    let location_field = city_field.fields[1]
        .as_struct()
        .expect("City.location should be Field::Struct");

    assert_eq!(
        location_field.fields.len(),
        2,
        "Location should have 2 fields: lat and lon"
    );

    // Check address.city.location.lat (index 0)
    let lat_field = location_field.fields[0]
        .as_primitive()
        .expect("Location.lat should be Field::Primitive");
    assert_eq!(
        lat_field.column, user_table.columns[3].id,
        "location.lat should map to address_city_location_lat column"
    );

    // Check address.city.location.lon (index 1)
    let lon_field = location_field.fields[1]
        .as_primitive()
        .expect("Location.lon should be Field::Primitive");
    assert_eq!(
        lon_field.column, user_table.columns[4].id,
        "location.lon should map to address_city_location_lon column"
    );

    // Check that the columns map is correctly populated at each level
    // Address level should contain all 4 columns (street, city_name, city_location_lat, city_location_lon)
    assert_eq!(
        address_field.columns.len(),
        4,
        "Address.columns should have 4 entries"
    );
    assert!(
        address_field
            .columns
            .contains_key(&user_table.columns[1].id),
        "Address.columns should contain address_street"
    );
    assert!(
        address_field
            .columns
            .contains_key(&user_table.columns[2].id),
        "Address.columns should contain address_city_name"
    );
    assert!(
        address_field
            .columns
            .contains_key(&user_table.columns[3].id),
        "Address.columns should contain address_city_location_lat"
    );
    assert!(
        address_field
            .columns
            .contains_key(&user_table.columns[4].id),
        "Address.columns should contain address_city_location_lon"
    );

    // City level should contain 3 columns (name, location_lat, location_lon)
    assert_eq!(
        city_field.columns.len(),
        3,
        "City.columns should have 3 entries"
    );
    assert!(
        city_field.columns.contains_key(&user_table.columns[2].id),
        "City.columns should contain address_city_name"
    );
    assert!(
        city_field.columns.contains_key(&user_table.columns[3].id),
        "City.columns should contain address_city_location_lat"
    );
    assert!(
        city_field.columns.contains_key(&user_table.columns[4].id),
        "City.columns should contain address_city_location_lon"
    );

    // Location level should contain 2 columns (lat, lon)
    assert_eq!(
        location_field.columns.len(),
        2,
        "Location.columns should have 2 entries"
    );
    assert!(
        location_field
            .columns
            .contains_key(&user_table.columns[3].id),
        "Location.columns should contain address_city_location_lat"
    );
    assert!(
        location_field
            .columns
            .contains_key(&user_table.columns[4].id),
        "Location.columns should contain address_city_location_lon"
    );

    // Verify model_to_table has correct nested projection expressions
    // Should have 5 expressions: id, address.street, address.city.name, address.city.location.lat, address.city.location.lon
    assert_eq!(
        user_mapping.model_to_table.len(),
        5,
        "model_to_table should have 5 expressions"
    );

    // Expression for address.street should be: project(ref(address_field), [0])
    assert_struct!(
        user_mapping.model_to_table[1],
        == stmt::Expr::project(
            stmt::Expr::ref_self_field(user.as_root_unwrap().fields[1].id),
            [0],
        )
    );

    // Expression for address.city.name should be: project(ref(address_field), [1, 0])
    assert_struct!(
        user_mapping.model_to_table[2],
        == stmt::Expr::project(
            stmt::Expr::ref_self_field(user.as_root_unwrap().fields[1].id),
            [1, 0],
        )
    );

    // Expression for address.city.location.lat should be: project(ref(address_field), [1, 1, 0])
    assert_struct!(
        user_mapping.model_to_table[3],
        == stmt::Expr::project(
            stmt::Expr::ref_self_field(user.as_root_unwrap().fields[1].id),
            [1, 1, 0],
        )
    );

    // Expression for address.city.location.lon should be: project(ref(address_field), [1, 1, 1])
    assert_struct!(
        user_mapping.model_to_table[4],
        == stmt::Expr::project(
            stmt::Expr::ref_self_field(user.as_root_unwrap().fields[1].id),
            [1, 1, 1],
        )
    );
}

/// Tests CRUD operations with 2-level nested embedded structs.
/// Validates that creating, reading, updating (instance and query-based),
/// and deleting records with nested embedded structs works end-to-end.
#[driver_test(scenario(crate::scenarios::company_office_address))]
pub async fn crud_nested_embedded(t: &mut Test) -> Result<()> {
    let mut db = setup(t).await;

    // Create: nested embedded structs are flattened into a single row
    let mut company = Company::create()
        .name("Acme")
        .headquarters(Office {
            name: "Main Office".to_string(),
            address: Address {
                street: "123 Main St".to_string(),
                city: "Springfield".to_string(),
            },
        })
        .exec(&mut db)
        .await?;

    assert_struct!(company.headquarters, {
        name: "Main Office",
        address: {
            street: "123 Main St",
            city: "Springfield",
        },
    });

    // Read: nested embedded struct is reconstructed from flattened columns
    let found = Company::get_by_id(&mut db, &company.id).await?;
    assert_struct!(found.headquarters, {
        name: "Main Office",
        address: {
            street: "123 Main St",
            city: "Springfield",
        },
    });

    // Update (instance): replace the entire nested embedded struct
    company
        .update()
        .headquarters(Office {
            name: "West Coast HQ".to_string(),
            address: Address {
                street: "456 Oak Ave".to_string(),
                city: "Seattle".to_string(),
            },
        })
        .exec(&mut db)
        .await?;

    let found = Company::get_by_id(&mut db, &company.id).await?;
    assert_struct!(found.headquarters, {
        name: "West Coast HQ",
        address: {
            street: "456 Oak Ave",
            city: "Seattle",
        },
    });

    // Update (query-based): replace nested struct via filter
    Company::filter_by_id(company.id)
        .update()
        .headquarters(Office {
            name: "East Coast HQ".to_string(),
            address: Address {
                street: "789 Pine Rd".to_string(),
                city: "Boston".to_string(),
            },
        })
        .exec(&mut db)
        .await?;

    let found = Company::get_by_id(&mut db, &company.id).await?;
    assert_struct!(found.headquarters, {
        name: "East Coast HQ",
        address: {
            street: "789 Pine Rd",
            city: "Boston",
        },
    });

    // Delete: cleanup
    let id = company.id;
    company.delete().exec(&mut db).await?;
    assert_err!(Company::get_by_id(&mut db, &id).await);
    Ok(())
}

/// Tests partial updates of deeply nested embedded fields via nested
/// `stmt::patch` calls. Validates that patching a leaf field inside an
/// outer embedded struct updates only that leaf, leaving all other fields
/// unchanged in the database.
#[driver_test(scenario(crate::scenarios::company_office_address))]
pub async fn partial_update_nested_embedded(t: &mut Test) -> Result<()> {
    let mut db = setup(t).await;

    let mut company = Company::create()
        .name("Acme")
        .headquarters(Office {
            name: "Main Office".to_string(),
            address: Address {
                street: "123 Main St".to_string(),
                city: "Boston".to_string(),
            },
        })
        .exec(&mut db)
        .await?;

    // Nested partial update: change only the city inside headquarters.address.
    // street and headquarters.name must remain unchanged.
    company
        .update()
        .headquarters(toasty::stmt::patch(
            Office::fields().address().city(),
            "Seattle",
        ))
        .exec(&mut db)
        .await?;

    let found = Company::get_by_id(&mut db, &company.id).await?;
    assert_struct!(found.headquarters, {
        name: "Main Office",
        address: {
            street: "123 Main St",
            city: "Seattle",
        },
    });

    // Partial update at the outer level: change only headquarters.name.
    // address fields must remain unchanged.
    company
        .update()
        .headquarters(toasty::stmt::patch(
            Office::fields().name(),
            "West Coast HQ",
        ))
        .exec(&mut db)
        .await?;

    let found = Company::get_by_id(&mut db, &company.id).await?;
    assert_struct!(found.headquarters, {
        name: "West Coast HQ",
        address: {
            street: "123 Main St",
            city: "Seattle",
        },
    });

    // Combined update: change headquarters.name and headquarters.address.city
    // in a single call via stmt::apply. street must remain unchanged.
    company
        .update()
        .headquarters(toasty::stmt::apply([
            toasty::stmt::patch(Office::fields().name(), "East Coast HQ"),
            toasty::stmt::patch(Office::fields().address().city(), "Boston"),
        ]))
        .exec(&mut db)
        .await?;

    let found = Company::get_by_id(&mut db, &company.id).await?;
    assert_struct!(found.headquarters, {
        name: "East Coast HQ",
        address: {
            street: "123 Main St",
            city: "Boston",
        },
    });
    Ok(())
}

/// Tests partial updates of embedded fields using the query/filter-based path.
/// `User::filter_by_id(id).update().address(stmt::patch(...))` follows a different
/// code path than the instance-based `user.update().address(stmt::patch(...))`,
/// so both need coverage.
#[driver_test(scenario(crate::scenarios::user_with_zip_address))]
pub async fn query_based_partial_update_embedded(t: &mut Test) -> Result<()> {
    let mut db = setup(t).await;

    let user = User::create()
        .name("Alice")
        .address(Address {
            street: "123 Main St".to_string(),
            city: "Boston".to_string(),
            zip: "02101".to_string(),
        })
        .exec(&mut db)
        .await?;

    // Single field: filter-based partial update targeting only city.
    // street and zip must remain unchanged.
    User::filter_by_id(user.id)
        .update()
        .address(toasty::stmt::patch(Address::fields().city(), "Seattle"))
        .exec(&mut db)
        .await?;

    let found = User::get_by_id(&mut db, &user.id).await?;
    assert_struct!(found.address, {
        street: "123 Main St",
        city: "Seattle",
        zip: "02101",
    });

    // Multiple fields: update city and zip together, leave street unchanged.
    User::filter_by_id(user.id)
        .update()
        .address(toasty::stmt::apply([
            toasty::stmt::patch(Address::fields().city(), "Portland"),
            toasty::stmt::patch(Address::fields().zip(), "97201"),
        ]))
        .exec(&mut db)
        .await?;

    let found = User::get_by_id(&mut db, &user.id).await?;
    assert_struct!(found.address, {
        street: "123 Main St",
        city: "Portland",
        zip: "97201",
    });
    Ok(())
}

/// Tests that jiff temporal types inside embedded structs round-trip correctly.
/// Covers Timestamp (epoch nanos), civil::Date, civil::Time, and civil::DateTime.
#[driver_test]
pub async fn embedded_struct_with_jiff_fields(t: &mut Test) -> Result<()> {
    #[derive(Debug, toasty::Embed)]
    struct Schedule {
        starts_at: jiff::Timestamp,
        due_date: jiff::civil::Date,
        reminder_time: jiff::civil::Time,
        scheduled_at: jiff::civil::DateTime,
    }

    #[derive(Debug, toasty::Model)]
    struct Event {
        #[key]
        #[auto]
        id: uuid::Uuid,
        name: String,
        schedule: Schedule,
    }

    let mut db = t.setup_db(models!(Event)).await;

    let starts_at = jiff::Timestamp::from_second(1_700_000_000).unwrap();
    let due_date = jiff::civil::date(2025, 6, 15);
    let reminder_time = jiff::civil::time(9, 30, 0, 0);
    let scheduled_at = jiff::civil::datetime(2025, 6, 15, 9, 30, 0, 0);

    let event = Event::create()
        .name("team sync")
        .schedule(Schedule {
            starts_at,
            due_date,
            reminder_time,
            scheduled_at,
        })
        .exec(&mut db)
        .await?;

    let found = Event::get_by_id(&mut db, &event.id).await?;
    assert_struct!(found.schedule, {
        starts_at: == starts_at,
        due_date: == due_date,
        reminder_time: == reminder_time,
        scheduled_at: == scheduled_at,
    });
    Ok(())
}

/// Tests a unit enum embedded as a field inside an embedded struct (enum-in-struct nesting).
/// The struct flattens to columns including the enum's discriminant column.
#[driver_test]
pub async fn unit_enum_in_embedded_struct(t: &mut Test) -> Result<()> {
    #[derive(Debug, PartialEq, toasty::Embed)]
    enum Priority {
        #[column(variant = 1)]
        Low,
        #[column(variant = 2)]
        Normal,
        #[column(variant = 3)]
        High,
    }

    #[derive(Debug, toasty::Embed)]
    struct Meta {
        label: String,
        priority: Priority,
    }

    #[derive(Debug, toasty::Model)]
    struct Task {
        #[key]
        #[auto]
        id: uuid::Uuid,
        meta: Meta,
    }

    let mut db = t.setup_db(models!(Task)).await;

    let mut task = Task::create()
        .meta(Meta {
            label: "fix bug".to_string(),
            priority: Priority::High,
        })
        .exec(&mut db)
        .await?;

    let found = Task::get_by_id(&mut db, &task.id).await?;
    assert_eq!(found.meta.label, "fix bug");
    assert_eq!(found.meta.priority, Priority::High);

    task.update()
        .meta(toasty::stmt::patch(
            Meta::fields().priority().into(),
            Priority::Normal,
        ))
        .exec(&mut db)
        .await?;

    let found = Task::get_by_id(&mut db, &task.id).await?;
    assert_eq!(found.meta.priority, Priority::Normal);

    Ok(())
}

/// Tests that UUID fields inside embedded structs round-trip correctly.
/// UUID requires a type cast on databases that don't support it natively
/// (e.g., SQLite stores it as text). This exercises the table_to_model
/// lifting path for embedded struct fields with non-trivial type mappings.
#[driver_test]
pub async fn embedded_struct_with_uuid_field(t: &mut Test) -> Result<()> {
    #[derive(Debug, toasty::Embed)]
    struct Meta {
        ref_id: Uuid,
        label: String,
    }

    #[derive(Debug, toasty::Model)]
    struct Item {
        #[key]
        #[auto]
        id: uuid::Uuid,
        name: String,
        meta: Meta,
    }

    let mut db = t.setup_db(models!(Item)).await;

    let ref_id = Uuid::new_v4();

    let item = Item::create()
        .name("widget")
        .meta(Meta {
            ref_id,
            label: "v1".to_string(),
        })
        .exec(&mut db)
        .await?;

    // Read back and verify the UUID survived the round-trip
    let found = Item::get_by_id(&mut db, &item.id).await?;
    assert_eq!(found.meta.ref_id, ref_id);
    assert_eq!(found.meta.label, "v1");

    Ok(())
}