feat: link mech data to construction reference tables via FK resolution

Add FK columns to unit_mech_data for all 7 component types, with alias
mapping tables to resolve MegaMek free-text values. DataLoaders prevent
N+1 queries when resolving component types in GraphQL.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: graylikeme

crates/api/src/db/models.rs

@@ -165,6 +165,13 @@ pub struct DbMechData {
     pub gyro_type: Option<String>,
     pub cockpit_type: Option<String>,
     pub myomer_type: Option<String>,
+    pub engine_type_id: Option<i32>,
+    pub armor_type_id: Option<i32>,
+    pub structure_type_id: Option<i32>,
+    pub heatsink_type_id: Option<i32>,
+    pub gyro_type_id: Option<i32>,
+    pub cockpit_type_id: Option<i32>,
+    pub myomer_type_id: Option<i32>,
 }
 
 // ── Construction Reference ───────────────────────────────────────────────

crates/api/src/db/units.rs

@@ -244,14 +244,15 @@ pub async fn get_mech_data_batch(
     pool: &PgPool,
     unit_ids: &[i32],
 ) -> Result<Vec<DbMechData>, AppError> {
-    let rows = sqlx::query_as!(
-        DbMechData,
+    let rows = sqlx::query_as::<_, DbMechData>(
         r#"SELECT unit_id, config, is_omnimech, engine_rating, engine_type,
                   walk_mp, jump_mp, heat_sink_count, heat_sink_type,
-                  structure_type, armor_type, gyro_type, cockpit_type, myomer_type
+                  structure_type, armor_type, gyro_type, cockpit_type, myomer_type,
+                  engine_type_id, armor_type_id, structure_type_id, heatsink_type_id,
+                  gyro_type_id, cockpit_type_id, myomer_type_id
            FROM unit_mech_data WHERE unit_id = ANY($1)"#,
-        unit_ids
     )
+    .bind(unit_ids)
     .fetch_all(pool)
     .await?;
     Ok(rows)

crates/api/src/graphql/loaders.rs

@@ -3,7 +3,10 @@ use std::collections::HashMap;
 use async_graphql::dataloader::Loader;
 
 use crate::db::{
-    models::{DbEquipment, DbMechData},
+    models::{
+        DbArmorType, DbCockpitType, DbEngineType, DbEquipment, DbGyroType, DbHeatsinkType,
+        DbMechData, DbMyomerType, DbStructureType,
+    },
     units,
 };
 
@@ -94,3 +97,159 @@ impl Loader<i32> for AmmoTypesLoader {
         Ok(map)
     }
 }
+
+// ── Component Type Loaders (for MechData FK resolution) ──────────────────────
+
+pub struct EngineTypeLoader {
+    pub pool: sqlx::PgPool,
+}
+
+impl Loader<i32> for EngineTypeLoader {
+    type Value = DbEngineType;
+    type Error = async_graphql::Error;
+
+    async fn load(&self, keys: &[i32]) -> Result<HashMap<i32, DbEngineType>, async_graphql::Error> {
+        let rows = sqlx::query_as::<_, DbEngineType>(
+            r#"SELECT id, slug, name, tech_base::text AS tech_base,
+                      rules_level::text AS rules_level,
+                      weight_multiplier, ct_crits, st_crits, intro_year
+               FROM engine_types WHERE id = ANY($1)"#,
+        )
+        .bind(keys)
+        .fetch_all(&self.pool)
+        .await?;
+        Ok(rows.into_iter().map(|r| (r.id, r)).collect())
+    }
+}
+
+pub struct ArmorTypeLoader {
+    pub pool: sqlx::PgPool,
+}
+
+impl Loader<i32> for ArmorTypeLoader {
+    type Value = DbArmorType;
+    type Error = async_graphql::Error;
+
+    async fn load(&self, keys: &[i32]) -> Result<HashMap<i32, DbArmorType>, async_graphql::Error> {
+        let rows = sqlx::query_as::<_, DbArmorType>(
+            r#"SELECT id, slug, name, tech_base::text AS tech_base,
+                      rules_level::text AS rules_level,
+                      points_per_ton, crits, intro_year
+               FROM armor_types WHERE id = ANY($1)"#,
+        )
+        .bind(keys)
+        .fetch_all(&self.pool)
+        .await?;
+        Ok(rows.into_iter().map(|r| (r.id, r)).collect())
+    }
+}
+
+pub struct StructureTypeLoader {
+    pub pool: sqlx::PgPool,
+}
+
+impl Loader<i32> for StructureTypeLoader {
+    type Value = DbStructureType;
+    type Error = async_graphql::Error;
+
+    async fn load(&self, keys: &[i32]) -> Result<HashMap<i32, DbStructureType>, async_graphql::Error> {
+        let rows = sqlx::query_as::<_, DbStructureType>(
+            r#"SELECT id, slug, name, tech_base::text AS tech_base,
+                      rules_level::text AS rules_level,
+                      weight_fraction, crits, intro_year
+               FROM structure_types WHERE id = ANY($1)"#,
+        )
+        .bind(keys)
+        .fetch_all(&self.pool)
+        .await?;
+        Ok(rows.into_iter().map(|r| (r.id, r)).collect())
+    }
+}
+
+pub struct HeatsinkTypeLoader {
+    pub pool: sqlx::PgPool,
+}
+
+impl Loader<i32> for HeatsinkTypeLoader {
+    type Value = DbHeatsinkType;
+    type Error = async_graphql::Error;
+
+    async fn load(&self, keys: &[i32]) -> Result<HashMap<i32, DbHeatsinkType>, async_graphql::Error> {
+        let rows = sqlx::query_as::<_, DbHeatsinkType>(
+            r#"SELECT id, slug, name, tech_base::text AS tech_base,
+                      rules_level::text AS rules_level,
+                      dissipation, crits, weight, intro_year
+               FROM heatsink_types WHERE id = ANY($1)"#,
+        )
+        .bind(keys)
+        .fetch_all(&self.pool)
+        .await?;
+        Ok(rows.into_iter().map(|r| (r.id, r)).collect())
+    }
+}
+
+pub struct GyroTypeLoader {
+    pub pool: sqlx::PgPool,
+}
+
+impl Loader<i32> for GyroTypeLoader {
+    type Value = DbGyroType;
+    type Error = async_graphql::Error;
+
+    async fn load(&self, keys: &[i32]) -> Result<HashMap<i32, DbGyroType>, async_graphql::Error> {
+        let rows = sqlx::query_as::<_, DbGyroType>(
+            r#"SELECT id, slug, name, tech_base::text AS tech_base,
+                      rules_level::text AS rules_level,
+                      weight_multiplier, crits, is_superheavy_only, intro_year
+               FROM gyro_types WHERE id = ANY($1)"#,
+        )
+        .bind(keys)
+        .fetch_all(&self.pool)
+        .await?;
+        Ok(rows.into_iter().map(|r| (r.id, r)).collect())
+    }
+}
+
+pub struct CockpitTypeLoader {
+    pub pool: sqlx::PgPool,
+}
+
+impl Loader<i32> for CockpitTypeLoader {
+    type Value = DbCockpitType;
+    type Error = async_graphql::Error;
+
+    async fn load(&self, keys: &[i32]) -> Result<HashMap<i32, DbCockpitType>, async_graphql::Error> {
+        let rows = sqlx::query_as::<_, DbCockpitType>(
+            r#"SELECT id, slug, name, tech_base::text AS tech_base,
+                      rules_level::text AS rules_level,
+                      weight, crits, intro_year
+               FROM cockpit_types WHERE id = ANY($1)"#,
+        )
+        .bind(keys)
+        .fetch_all(&self.pool)
+        .await?;
+        Ok(rows.into_iter().map(|r| (r.id, r)).collect())
+    }
+}
+
+pub struct MyomerTypeLoader {
+    pub pool: sqlx::PgPool,
+}
+
+impl Loader<i32> for MyomerTypeLoader {
+    type Value = DbMyomerType;
+    type Error = async_graphql::Error;
+
+    async fn load(&self, keys: &[i32]) -> Result<HashMap<i32, DbMyomerType>, async_graphql::Error> {
+        let rows = sqlx::query_as::<_, DbMyomerType>(
+            r#"SELECT id, slug, name, tech_base::text AS tech_base,
+                      rules_level::text AS rules_level,
+                      intro_year, properties
+               FROM myomer_types WHERE id = ANY($1)"#,
+        )
+        .bind(keys)
+        .fetch_all(&self.pool)
+        .await?;
+        Ok(rows.into_iter().map(|r| (r.id, r)).collect())
+    }
+}

crates/api/src/graphql/schema.rs

@@ -2,7 +2,11 @@ use async_graphql::{dataloader::DataLoader, EmptyMutation, EmptySubscription, Sc
 
 use crate::{
     graphql::{
-        loaders::{AmmoForLoader, AmmoTypesLoader, MechDataLoader},
+        loaders::{
+            AmmoForLoader, AmmoTypesLoader, ArmorTypeLoader, CockpitTypeLoader, EngineTypeLoader,
+            GyroTypeLoader, HeatsinkTypeLoader, MechDataLoader, MyomerTypeLoader,
+            StructureTypeLoader,
+        },
         query::QueryRoot,
     },
     state::AppState,
@@ -15,12 +19,26 @@ pub fn build(state: AppState) -> AppSchema {
     let mech_loader = DataLoader::new(MechDataLoader { pool: pool.clone() }, tokio::spawn);
     let ammo_for_loader = DataLoader::new(AmmoForLoader { pool: pool.clone() }, tokio::spawn);
     let ammo_types_loader = DataLoader::new(AmmoTypesLoader { pool: pool.clone() }, tokio::spawn);
+    let engine_type_loader = DataLoader::new(EngineTypeLoader { pool: pool.clone() }, tokio::spawn);
+    let armor_type_loader = DataLoader::new(ArmorTypeLoader { pool: pool.clone() }, tokio::spawn);
+    let structure_type_loader = DataLoader::new(StructureTypeLoader { pool: pool.clone() }, tokio::spawn);
+    let heatsink_type_loader = DataLoader::new(HeatsinkTypeLoader { pool: pool.clone() }, tokio::spawn);
+    let gyro_type_loader = DataLoader::new(GyroTypeLoader { pool: pool.clone() }, tokio::spawn);
+    let cockpit_type_loader = DataLoader::new(CockpitTypeLoader { pool: pool.clone() }, tokio::spawn);
+    let myomer_type_loader = DataLoader::new(MyomerTypeLoader { pool: pool.clone() }, tokio::spawn);
 
     Schema::build(QueryRoot, EmptyMutation, EmptySubscription)
         .data(state)
         .data(mech_loader)
         .data(ammo_for_loader)
         .data(ammo_types_loader)
+        .data(engine_type_loader)
+        .data(armor_type_loader)
+        .data(structure_type_loader)
+        .data(heatsink_type_loader)
+        .data(gyro_type_loader)
+        .data(cockpit_type_loader)
+        .data(myomer_type_loader)
         .limit_depth(20)
         .limit_complexity(500)
         .finish()