feat: add cumulative rulesLevel filter to allChassis query

Add rulesLevel parameter to the allChassis GraphQL query, filtering to
chassis with at least one variant at or below the given rules level.
Also change all existing rulesLevel filters (units, equipment,
construction reference) from exact match to cumulative — e.g. ADVANCED
now includes introductory, standard, and advanced, matching BattleTech's
hierarchical rules level system.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: graylikeme

crates/api/src/db/construction.rs

@@ -24,8 +24,9 @@ pub async fn list_engine_types(
         builder.push_bind(tb);
     }
     if let Some(rl) = rules_level {
-        builder.push(" AND rules_level::text = ");
+        builder.push(" AND rules_level <= ");
         builder.push_bind(rl);
+        builder.push("::rules_level_enum");
     }
     builder.push(" ORDER BY name");
     Ok(builder.build_query_as::<DbEngineType>().fetch_all(pool).await?)
@@ -47,8 +48,9 @@ pub async fn list_armor_types(
         builder.push_bind(tb);
     }
     if let Some(rl) = rules_level {
-        builder.push(" AND rules_level::text = ");
+        builder.push(" AND rules_level <= ");
         builder.push_bind(rl);
+        builder.push("::rules_level_enum");
     }
     builder.push(" ORDER BY name");
     Ok(builder.build_query_as::<DbArmorType>().fetch_all(pool).await?)
@@ -70,8 +72,9 @@ pub async fn list_structure_types(
         builder.push_bind(tb);
     }
     if let Some(rl) = rules_level {
-        builder.push(" AND rules_level::text = ");
+        builder.push(" AND rules_level <= ");
         builder.push_bind(rl);
+        builder.push("::rules_level_enum");
     }
     builder.push(" ORDER BY name");
     Ok(builder.build_query_as::<DbStructureType>().fetch_all(pool).await?)
@@ -93,8 +96,9 @@ pub async fn list_heatsink_types(
         builder.push_bind(tb);
     }
     if let Some(rl) = rules_level {
-        builder.push(" AND rules_level::text = ");
+        builder.push(" AND rules_level <= ");
         builder.push_bind(rl);
+        builder.push("::rules_level_enum");
     }
     builder.push(" ORDER BY name");
     Ok(builder.build_query_as::<DbHeatsinkType>().fetch_all(pool).await?)
@@ -111,8 +115,9 @@ pub async fn list_gyro_types(
            FROM gyro_types WHERE TRUE"#,
     );
     if let Some(rl) = rules_level {
-        builder.push(" AND rules_level::text = ");
+        builder.push(" AND rules_level <= ");
         builder.push_bind(rl);
+        builder.push("::rules_level_enum");
     }
     builder.push(" ORDER BY name");
     Ok(builder.build_query_as::<DbGyroType>().fetch_all(pool).await?)
@@ -129,8 +134,9 @@ pub async fn list_cockpit_types(
            FROM cockpit_types WHERE TRUE"#,
     );
     if let Some(rl) = rules_level {
-        builder.push(" AND rules_level::text = ");
+        builder.push(" AND rules_level <= ");
         builder.push_bind(rl);
+        builder.push("::rules_level_enum");
     }
     builder.push(" ORDER BY name");
     Ok(builder.build_query_as::<DbCockpitType>().fetch_all(pool).await?)
@@ -147,8 +153,9 @@ pub async fn list_myomer_types(
            FROM myomer_types WHERE TRUE"#,
     );
     if let Some(rl) = rules_level {
-        builder.push(" AND rules_level::text = ");
+        builder.push(" AND rules_level <= ");
         builder.push_bind(rl);
+        builder.push("::rules_level_enum");
     }
     builder.push(" ORDER BY name");
     Ok(builder.build_query_as::<DbMyomerType>().fetch_all(pool).await?)

crates/api/src/db/equipment.rs

@@ -79,8 +79,9 @@ pub async fn search(
         builder.push_bind(tb);
     }
     if let Some(rl) = filter.rules_level {
-        builder.push(" AND rules_level::text = ");
+        builder.push(" AND rules_level <= ");
         builder.push_bind(rl);
+        builder.push("::rules_level_enum");
     }
     if let Some(max_t) = filter.max_tonnage {
         builder.push(" AND tonnage IS NOT NULL AND tonnage <= ");

crates/api/src/db/units.rs

@@ -112,8 +112,9 @@ pub async fn search(
         builder.push_bind(tb);
     }
     if let Some(rl) = filter.rules_level {
-        builder.push(" AND u.rules_level::text = ");
+        builder.push(" AND u.rules_level <= ");
         builder.push_bind(rl);
+        builder.push("::rules_level_enum");
     }
     if let Some(min) = filter.tonnage_min {
         builder.push(" AND u.tonnage >= ");
@@ -233,6 +234,7 @@ pub async fn list_chassis(
     pool: &PgPool,
     unit_type: Option<&str>,
     tech_base: Option<&str>,
+    rules_level: Option<&str>,
 ) -> Result<Vec<DbUnitChassis>, AppError> {
     let mut builder = sqlx::QueryBuilder::<sqlx::Postgres>::new(
         r#"SELECT id, slug, name, unit_type, tech_base::text AS tech_base,
@@ -248,6 +250,11 @@ pub async fn list_chassis(
         builder.push(" AND tech_base::text = ");
         builder.push_bind(tb);
     }
+    if let Some(rl) = rules_level {
+        builder.push(" AND EXISTS (SELECT 1 FROM units u WHERE u.chassis_id = unit_chassis.id AND u.rules_level <= ");
+        builder.push_bind(rl);
+        builder.push("::rules_level_enum)");
+    }
 
     builder.push(" ORDER BY name");
 
@@ -623,6 +630,108 @@ mod tests {
         assert_eq!(total, 6, "no filter should return all 6 units");
     }
 
+    async fn seed_chassis_with_rules_levels(pool: &PgPool) {
+        sqlx::query(
+            "INSERT INTO unit_chassis (slug, name, unit_type, tech_base, tonnage)
+             VALUES ('atlas-mech', 'Atlas', 'BattleMech', 'inner_sphere', 100),
+                    ('timber-wolf-mech', 'Timber Wolf', 'BattleMech', 'clan', 75),
+                    ('empty-mech', 'Empty', 'BattleMech', 'inner_sphere', 50)",
+        )
+        .execute(pool)
+        .await
+        .unwrap();
+
+        let atlas_id: i32 =
+            sqlx::query_scalar("SELECT id FROM unit_chassis WHERE slug = 'atlas-mech'")
+                .fetch_one(pool)
+                .await
+                .unwrap();
+        let tw_id: i32 =
+            sqlx::query_scalar("SELECT id FROM unit_chassis WHERE slug = 'timber-wolf-mech'")
+                .fetch_one(pool)
+                .await
+                .unwrap();
+        // empty-mech has no units — should never appear in rules_level filtered results
+
+        // Atlas has introductory + standard variants
+        for (slug, variant, full_name, rl) in [
+            ("atlas-as7-d", "AS7-D", "Atlas AS7-D", "introductory"),
+            ("atlas-as7-k", "AS7-K", "Atlas AS7-K", "standard"),
+        ] {
+            sqlx::query(
+                "INSERT INTO units (slug, chassis_id, variant, full_name, tech_base, rules_level, tonnage)
+                 VALUES ($1, $2, $3, $4, 'inner_sphere', $5::rules_level_enum, 100)",
+            )
+            .bind(slug)
+            .bind(atlas_id)
+            .bind(variant)
+            .bind(full_name)
+            .bind(rl)
+            .execute(pool)
+            .await
+            .unwrap();
+        }
+
+        // Timber Wolf has only advanced variants
+        sqlx::query(
+            "INSERT INTO units (slug, chassis_id, variant, full_name, tech_base, rules_level, tonnage)
+             VALUES ('timber-wolf-prime', $1, 'Prime', 'Timber Wolf Prime', 'clan', 'advanced'::rules_level_enum, 75)",
+        )
+        .bind(tw_id)
+        .execute(pool)
+        .await
+        .unwrap();
+    }
+
+    #[sqlx::test(migrations = "../../migrations")]
+    async fn chassis_rules_level_filter_is_cumulative(pool: PgPool) {
+        seed_chassis_with_rules_levels(&pool).await;
+
+        // Introductory — only Atlas (has an introductory variant)
+        let rows = list_chassis(&pool, None, None, Some("introductory")).await.unwrap();
+        assert_eq!(rows.len(), 1);
+        assert_eq!(rows[0].slug, "atlas-mech");
+
+        // Standard — still only Atlas (introductory + standard both <= standard)
+        let rows = list_chassis(&pool, None, None, Some("standard")).await.unwrap();
+        assert_eq!(rows.len(), 1);
+        assert_eq!(rows[0].slug, "atlas-mech");
+
+        // Advanced — both chassis (Atlas intro/standard <= advanced, Timber Wolf advanced <= advanced)
+        let rows = list_chassis(&pool, None, None, Some("advanced")).await.unwrap();
+        assert_eq!(rows.len(), 2);
+        let slugs: Vec<&str> = rows.iter().map(|r| r.slug.as_str()).collect();
+        assert!(slugs.contains(&"atlas-mech"));
+        assert!(slugs.contains(&"timber-wolf-mech"));
+
+        // Experimental — still both (all variants <= experimental)
+        let rows = list_chassis(&pool, None, None, Some("experimental")).await.unwrap();
+        assert_eq!(rows.len(), 2);
+
+        // No filter — all 3 chassis (including empty one with no units)
+        let rows = list_chassis(&pool, None, None, None).await.unwrap();
+        assert_eq!(rows.len(), 3);
+    }
+
+    #[sqlx::test(migrations = "../../migrations")]
+    async fn chassis_rules_level_combined_with_tech_base(pool: PgPool) {
+        seed_chassis_with_rules_levels(&pool).await;
+
+        // Clan + advanced → Timber Wolf (advanced <= advanced)
+        let rows = list_chassis(&pool, None, Some("clan"), Some("advanced")).await.unwrap();
+        assert_eq!(rows.len(), 1);
+        assert_eq!(rows[0].slug, "timber-wolf-mech");
+
+        // Clan + standard → none (Timber Wolf only has advanced, which is > standard)
+        let rows = list_chassis(&pool, None, Some("clan"), Some("standard")).await.unwrap();
+        assert_eq!(rows.len(), 0);
+
+        // Inner Sphere + standard → Atlas (has intro + standard variants, both <= standard)
+        let rows = list_chassis(&pool, None, Some("inner_sphere"), Some("standard")).await.unwrap();
+        assert_eq!(rows.len(), 1);
+        assert_eq!(rows[0].slug, "atlas-mech");
+    }
+
     #[sqlx::test(migrations = "../../migrations")]
     async fn combined_bv_and_unit_type_filter(pool: PgPool) {
         seed_units_with_bv(&pool).await;

crates/api/src/graphql/query.rs

@@ -142,7 +142,7 @@ impl QueryRoot {
         #[graphql(desc = "Opaque cursor from a previous pageInfo.endCursor. Omit for the first page.")] after: Option<String>,
         #[graphql(desc = "Case-insensitive substring match against the unit's full name.")] name_search: Option<String>,
         #[graphql(desc = "Filter by technology base.")] tech_base: Option<TechBaseFilter>,
-        #[graphql(desc = "Filter by rules level.")] rules_level: Option<RulesLevelFilter>,
+        #[graphql(desc = "Filter by maximum rules level (cumulative). E.g. ADVANCED includes introductory, standard, and advanced.")] rules_level: Option<RulesLevelFilter>,
         #[graphql(desc = "Minimum tonnage filter (inclusive). Weight in metric tons.")] tonnage_min: Option<f64>,
         #[graphql(desc = "Maximum tonnage filter (inclusive). Weight in metric tons.")] tonnage_max: Option<f64>,
         #[graphql(desc = "Minimum Battle Value filter (inclusive).")] bv_min: Option<i32>,
@@ -233,18 +233,20 @@ impl QueryRoot {
         Ok(row.map(UnitChassisGql))
     }
 
-    /// List all chassis, optionally filtered by unit type and/or technology base.
+    /// List all chassis, optionally filtered by unit type, technology base, and/or rules level.
     async fn all_chassis(
         &self,
         ctx: &Context<'_>,
         #[graphql(desc = "Filter by unit type.")] unit_type: Option<UnitTypeFilter>,
         #[graphql(desc = "Filter by technology base.")] tech_base: Option<TechBaseFilter>,
+        #[graphql(desc = "Filter to chassis with at least one variant at or below this rules level (cumulative).")] rules_level: Option<RulesLevelFilter>,
     ) -> Result<Vec<UnitChassisGql>, AppError> {
         let state = ctx.data::<AppState>().unwrap();
         let rows = units::list_chassis(
             &state.pool,
             unit_type.map(|u| u.as_db_str()),
             tech_base.map(|t| t.as_db_str()),
+            rules_level.map(|r| r.as_db_str()),
         )
         .await?;
         Ok(rows.into_iter().map(UnitChassisGql).collect())
@@ -272,7 +274,7 @@ impl QueryRoot {
         #[graphql(desc = "Case-insensitive substring match against the equipment name.")] name_search: Option<String>,
         #[graphql(desc = "Filter by equipment category.")] category: Option<EquipmentCategoryFilter>,
         #[graphql(desc = "Filter by technology base.")] tech_base: Option<TechBaseFilter>,
-        #[graphql(desc = "Filter by rules level.")] rules_level: Option<RulesLevelFilter>,
+        #[graphql(desc = "Filter by maximum rules level (cumulative). E.g. ADVANCED includes introductory, standard, and advanced.")] rules_level: Option<RulesLevelFilter>,
         #[graphql(desc = "Filter to equipment weighing at most this many tons. Only matches items with known tonnage.")] max_tonnage: Option<f64>,
         #[graphql(desc = "Filter to equipment consuming at most this many critical slots. Only matches items with known crits.")] max_crits: Option<i32>,
         #[graphql(desc = "Filter to equipment observed in this location across existing units (e.g. \"right_arm\").")] observed_location: Option<String>,
@@ -397,7 +399,7 @@ impl QueryRoot {
         &self,
         ctx: &Context<'_>,
         #[graphql(desc = "Filter by technology base.")] tech_base: Option<TechBaseFilter>,
-        #[graphql(desc = "Filter by rules level.")] rules_level: Option<RulesLevelFilter>,
+        #[graphql(desc = "Filter by maximum rules level (cumulative). E.g. ADVANCED includes introductory, standard, and advanced.")] rules_level: Option<RulesLevelFilter>,
     ) -> Result<Vec<EngineTypeGql>, AppError> {
         let state = ctx.data::<AppState>().unwrap();
         let rows = construction::list_engine_types(
@@ -414,7 +416,7 @@ impl QueryRoot {
         &self,
         ctx: &Context<'_>,
         #[graphql(desc = "Filter by technology base.")] tech_base: Option<TechBaseFilter>,
-        #[graphql(desc = "Filter by rules level.")] rules_level: Option<RulesLevelFilter>,
+        #[graphql(desc = "Filter by maximum rules level (cumulative). E.g. ADVANCED includes introductory, standard, and advanced.")] rules_level: Option<RulesLevelFilter>,
     ) -> Result<Vec<ArmorTypeGql>, AppError> {
         let state = ctx.data::<AppState>().unwrap();
         let rows = construction::list_armor_types(
@@ -431,7 +433,7 @@ impl QueryRoot {
         &self,
         ctx: &Context<'_>,
         #[graphql(desc = "Filter by technology base.")] tech_base: Option<TechBaseFilter>,
-        #[graphql(desc = "Filter by rules level.")] rules_level: Option<RulesLevelFilter>,
+        #[graphql(desc = "Filter by maximum rules level (cumulative). E.g. ADVANCED includes introductory, standard, and advanced.")] rules_level: Option<RulesLevelFilter>,
     ) -> Result<Vec<StructureTypeGql>, AppError> {
         let state = ctx.data::<AppState>().unwrap();
         let rows = construction::list_structure_types(
@@ -448,7 +450,7 @@ impl QueryRoot {
         &self,
         ctx: &Context<'_>,
         #[graphql(desc = "Filter by technology base.")] tech_base: Option<TechBaseFilter>,
-        #[graphql(desc = "Filter by rules level.")] rules_level: Option<RulesLevelFilter>,
+        #[graphql(desc = "Filter by maximum rules level (cumulative). E.g. ADVANCED includes introductory, standard, and advanced.")] rules_level: Option<RulesLevelFilter>,
     ) -> Result<Vec<HeatsinkTypeGql>, AppError> {
         let state = ctx.data::<AppState>().unwrap();
         let rows = construction::list_heatsink_types(
@@ -464,7 +466,7 @@ impl QueryRoot {
     async fn gyro_types(
         &self,
         ctx: &Context<'_>,
-        #[graphql(desc = "Filter by rules level.")] rules_level: Option<RulesLevelFilter>,
+        #[graphql(desc = "Filter by maximum rules level (cumulative). E.g. ADVANCED includes introductory, standard, and advanced.")] rules_level: Option<RulesLevelFilter>,
     ) -> Result<Vec<GyroTypeGql>, AppError> {
         let state = ctx.data::<AppState>().unwrap();
         let rows = construction::list_gyro_types(
@@ -479,7 +481,7 @@ impl QueryRoot {
     async fn cockpit_types(
         &self,
         ctx: &Context<'_>,
-        #[graphql(desc = "Filter by rules level.")] rules_level: Option<RulesLevelFilter>,
+        #[graphql(desc = "Filter by maximum rules level (cumulative). E.g. ADVANCED includes introductory, standard, and advanced.")] rules_level: Option<RulesLevelFilter>,
     ) -> Result<Vec<CockpitTypeGql>, AppError> {
         let state = ctx.data::<AppState>().unwrap();
         let rows = construction::list_cockpit_types(
@@ -494,7 +496,7 @@ impl QueryRoot {
     async fn myomer_types(
         &self,
         ctx: &Context<'_>,
-        #[graphql(desc = "Filter by rules level.")] rules_level: Option<RulesLevelFilter>,
+        #[graphql(desc = "Filter by maximum rules level (cumulative). E.g. ADVANCED includes introductory, standard, and advanced.")] rules_level: Option<RulesLevelFilter>,
     ) -> Result<Vec<MyomerTypeGql>, AppError> {
         let state = ctx.data::<AppState>().unwrap();
         let rows = construction::list_myomer_types(