feat: add optional rulesLevel filter to chassis.variants resolver

Extracts variant query into db::units::get_variants_by_chassis() with
optional cumulative rulesLevel filter, so clients can filter variants
server-side instead of fetching all and filtering on the client.

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

Author: graylikeme

.sqlx/query-68d94e0967f25365ccba20501b6934bedfb2a3cb767cc467e180c1fb93a79059.json

@@ -204,15 +204,16 @@ The server starts on `http://localhost:8080`. In debug builds, GraphiQL is avail
   }
 }
 
-# Chassis with all variants
+# Chassis with variants filtered by rules level
 {
   chassis(slug: "atlas-mech") {
     name
     unitType
     tonnage
-    variants {
+    variants(rulesLevel: STANDARD) {
       slug
       fullName
+      rulesLevel
       bv
       introYear
     }

README.md

@@ -265,6 +265,33 @@ pub async fn list_chassis(
     Ok(rows)
 }
 
+pub async fn get_variants_by_chassis(
+    pool: &PgPool,
+    chassis_id: i32,
+    rules_level: Option<&str>,
+) -> Result<Vec<DbUnit>, AppError> {
+    let mut builder = sqlx::QueryBuilder::<sqlx::Postgres>::new(
+        r#"SELECT u.id, u.slug, u.chassis_id, u.variant, u.full_name,
+                  u.tech_base::text AS tech_base, u.rules_level::text AS rules_level,
+                  u.tonnage, u.bv, u.cost, u.intro_year, u.extinction_year,
+                  u.reintro_year, u.source_book, u.description,
+                  u.mul_id, u.role, u.clan_name, NULL::bigint AS total_count
+           FROM units u WHERE u.chassis_id = "#,
+    );
+    builder.push_bind(chassis_id);
+    if let Some(rl) = rules_level {
+        builder.push(" AND u.rules_level <= ");
+        builder.push_bind(rl);
+        builder.push("::rules_level_enum");
+    }
+    builder.push(" ORDER BY u.variant");
+    let rows = builder
+        .build_query_as::<DbUnit>()
+        .fetch_all(pool)
+        .await?;
+    Ok(rows)
+}
+
 pub async fn get_locations(pool: &PgPool, unit_id: i32) -> Result<Vec<DbLocation>, AppError> {
     let rows = sqlx::query_as!(
         DbLocation,
@@ -732,6 +759,46 @@ mod tests {
         assert_eq!(rows[0].slug, "atlas-mech");
     }
 
+    #[sqlx::test(migrations = "../../migrations")]
+    async fn variants_rules_level_filter_is_cumulative(pool: PgPool) {
+        seed_chassis_with_rules_levels(&pool).await;
+
+        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();
+
+        // Atlas: has introductory (AS7-D) + standard (AS7-K)
+        // No filter — returns both
+        let rows = get_variants_by_chassis(&pool, atlas_id, None).await.unwrap();
+        assert_eq!(rows.len(), 2);
+
+        // Introductory — only AS7-D
+        let rows = get_variants_by_chassis(&pool, atlas_id, Some("introductory")).await.unwrap();
+        assert_eq!(rows.len(), 1);
+        assert_eq!(rows[0].slug, "atlas-as7-d");
+
+        // Standard — both (introductory + standard <= standard)
+        let rows = get_variants_by_chassis(&pool, atlas_id, Some("standard")).await.unwrap();
+        assert_eq!(rows.len(), 2);
+
+        // Timber Wolf: only advanced (Prime)
+        // Standard — none (advanced > standard)
+        let rows = get_variants_by_chassis(&pool, tw_id, Some("standard")).await.unwrap();
+        assert_eq!(rows.len(), 0);
+
+        // Advanced — returns Prime
+        let rows = get_variants_by_chassis(&pool, tw_id, Some("advanced")).await.unwrap();
+        assert_eq!(rows.len(), 1);
+        assert_eq!(rows[0].slug, "timber-wolf-prime");
+    }
+
     #[sqlx::test(migrations = "../../migrations")]
     async fn combined_bv_and_unit_type_filter(pool: PgPool) {
         seed_units_with_bv(&pool).await;

crates/api/src/db/units.rs

@@ -11,7 +11,7 @@ use crate::{
         },
         types::construction::{
             ArmorTypeGql, CockpitTypeGql, EngineTypeGql, GyroTypeGql, HeatsinkTypeGql,
-            MyomerTypeGql, StructureTypeGql,
+            MyomerTypeGql, RulesLevelFilter, StructureTypeGql,
         },
     },
     state::AppState,
@@ -114,20 +114,19 @@ impl UnitChassisGql {
     }
 
     /// All unit variants belonging to this chassis, ordered by variant designation.
+    /// Optionally filtered by maximum rules level (cumulative).
     #[graphql(complexity = 5)]
-    async fn variants(&self, ctx: &Context<'_>) -> Result<Vec<UnitGql>, AppError> {
+    async fn variants(
+        &self,
+        ctx: &Context<'_>,
+        #[graphql(desc = "Filter variants by maximum rules level (cumulative). E.g. ADVANCED includes introductory, standard, and advanced.")] rules_level: Option<RulesLevelFilter>,
+    ) -> Result<Vec<UnitGql>, AppError> {
         let state = ctx.data::<AppState>().unwrap();
-        let rows = sqlx::query_as!(
-            DbUnit,
-            r#"SELECT u.id, u.slug, u.chassis_id, u.variant, u.full_name,
-                      u.tech_base::text AS "tech_base!", u.rules_level::text AS "rules_level!",
-                      u.tonnage, u.bv, u.cost, u.intro_year, u.extinction_year,
-                      u.reintro_year, u.source_book, u.description,
-                      u.mul_id, u.role, u.clan_name, NULL::bigint AS total_count
-               FROM units u WHERE u.chassis_id = $1 ORDER BY u.variant"#,
-            self.0.id
+        let rows = crate::db::units::get_variants_by_chassis(
+            &state.pool,
+            self.0.id,
+            rules_level.map(|r| r.as_db_str()),
         )
-        .fetch_all(&state.pool)
         .await?;
         Ok(rows.into_iter().map(UnitGql).collect())
     }

crates/api/src/graphql/types/unit.rs

@@ -384,19 +384,20 @@ To paginate: pass `endCursor` from the previous response as `after` in the next
 }}
 ```
 
-### Get chassis with all its variants
+### Get chassis with variants filtered by rules level
 ```graphql
 {{
   chassis(slug: "atlas-mech") {{
     name
     unitType
     techBase
     tonnage
-    variants {{
+    variants(rulesLevel: STANDARD) {{
       slug
       variant
       fullName
       techBase
+      rulesLevel
       bv
       introYear
     }}